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

package/dist/Cascader/CascaderContext.js

@@ -0,0 +1,52 @@
+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/CascaderContext.ts
+var CascaderContext_exports = {};
+__export(CascaderContext_exports, {
+  CascaderContext: () => CascaderContext
+});
+module.exports = __toCommonJS(CascaderContext_exports);
+var import_noop = __toESM(require("lodash/noop"));
+var import_react = require("react");
+var CascaderContext = (0, import_react.createContext)({
+  onSelect: import_noop.default,
+  onCheckedChange: import_noop.default,
+  loading: null,
+  searchText: null,
+  menuProps: {},
+  treeMenuProps: {},
+  getExpandedKeys: () => [],
+  setExpandedKeys: import_noop.default,
+  getDataType: () => false,
+  getTreeData: () => []
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CascaderContext
+});

package/dist/Cascader/CascaderDropdown.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { OptionNode } from './typings';
+interface Props {
+    separator: string;
+    options: OptionNode[][];
+    value: string[] | string[][];
+    checkedNodes: () => OptionNode[][];
+}
+declare const CascaderDropdown: React.MemoExoticComponent<(props: Props) => React.JSX.Element>;
+export default CascaderDropdown;

package/dist/Cascader/CascaderDropdown.js

@@ -0,0 +1,81 @@
+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/CascaderDropdown.tsx
+var CascaderDropdown_exports = {};
+__export(CascaderDropdown_exports, {
+  default: () => CascaderDropdown_default
+});
+module.exports = __toCommonJS(CascaderDropdown_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_last = __toESM(require("lodash/last"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_Scrollbar = require("../Scrollbar");
+var import_hooks = require("../hooks");
+var import_CascaderContext = require("./CascaderContext");
+var CascaderDropdown = (0, import_react.memo)((props) => {
+  const { menuProps, onSelect, onCheckedChange } = (0, import_react.useContext)(import_CascaderContext.CascaderContext);
+  const { options, separator, value, checkedNodes } = props;
+  const { valueKey = "value", labelKey = "label", multiple } = menuProps;
+  const { e, is } = (0, import_hooks.useClassNames)("cascader");
+  const ulRef = (0, import_react.useRef)(null);
+  const scrollBarRef = (0, import_react.useRef)(null);
+  const [checkedNode, setCheckedNode] = (0, import_react.useState)(multiple ? value.map((item) => item.join(separator)) : [value.join(separator)]);
+  const list = (0, import_react.useMemo)(() => {
+    return options.map((item) => {
+      const key = item.map((node) => node[valueKey]).join(separator);
+      const checked = checkedNode.includes(key);
+      return /* @__PURE__ */ import_react.default.createElement(
+        "li",
+        {
+          className: (0, import_classnames.default)(e`suggestion-item`, is({ checked })),
+          key,
+          onClick: () => {
+            if (multiple) {
+              setCheckedNode(checked ? checkedNode.filter((node2) => node2 !== key) : [...checkedNode, key]);
+              item.forEach((node2) => {
+                onSelect(node2.__level, node2);
+              });
+              const node = (0, import_last.default)(item);
+              onCheckedChange(node.__level, node, !checked);
+            } else {
+              item.forEach((node) => {
+                onSelect(node.__level, node);
+              });
+            }
+          }
+        },
+        /* @__PURE__ */ import_react.default.createElement("span", null, item.map((node) => node[labelKey]).join(separator)),
+        multiple && checkedNode.includes(key) ? /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "check" }) : null
+      );
+    });
+  }, [checkedNode, e, is, labelKey, multiple, onCheckedChange, onSelect, options, separator, valueKey]);
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(e`dorpdown`), onClick: (event) => event.stopPropagation() }, /* @__PURE__ */ import_react.default.createElement(import_Scrollbar.Scrollbar, { wrapClass: e`suggestion-panel`, ref: scrollBarRef }, /* @__PURE__ */ import_react.default.createElement("ul", { className: e`suggestion-list`, ref: ulRef }, list, (options == null ? void 0 : options.length) === 0 && /* @__PURE__ */ import_react.default.createElement("li", { className: (0, import_classnames.default)(e`empty-text`) }, "暂无数据"))));
+});
+var CascaderDropdown_default = CascaderDropdown;

package/dist/Cascader/CascaderMenu.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { OptionNode } from './typings';
+interface Props {
+    data: OptionNode[];
+    level: number;
+    value: string;
+}
+export interface CascaderMenuRef {
+    scrollToSelected: () => void;
+}
+declare const CascaderMenu: React.MemoExoticComponent<React.ForwardRefExoticComponent<Props & React.RefAttributes<CascaderMenuRef>>>;
+export default CascaderMenu;

package/dist/Cascader/CascaderMenu.js

@@ -0,0 +1,191 @@
+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/CascaderMenu.tsx
+var CascaderMenu_exports = {};
+__export(CascaderMenu_exports, {
+  default: () => CascaderMenu_default
+});
+module.exports = __toCommonJS(CascaderMenu_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_flattenDeep = __toESM(require("lodash/flattenDeep"));
+var import_react = __toESM(require("react"));
+var import_scroll_into_view_if_needed = __toESM(require("scroll-into-view-if-needed"));
+var import_Checkbox = require("../Checkbox");
+var import_Icon = require("../Icon");
+var import_Scrollbar = require("../Scrollbar");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_CascaderContext = require("./CascaderContext");
+var CascaderMenu = (0, import_react.memo)(
+  (0, import_react.forwardRef)((props, ref) => {
+    const { data = [], level, value } = props;
+    const { menuProps, treeMenuProps, onSelect, onCheckedChange, getDataType, loading, getExpandedKeys, searchText } = (0, import_react.useContext)(import_CascaderContext.CascaderContext);
+    const { valueKey = "value", labelKey = "label", disabledKey = "disabled", multiple } = menuProps;
+    const { valueKey: treeValueKey = "key", labelKey: treeLabelKey = "title", childrenKey: treeChildrenKey } = treeMenuProps;
+    const { b, be, is } = (0, import_hooks.useClassNames)("cascader");
+    const treeRef = (0, import_react.useRef)();
+    const dataList = (0, import_react.useRef)([]);
+    const ulRef = (0, import_react.useRef)(null);
+    const isTree = (0, import_react.useMemo)(() => {
+      return getDataType(level);
+    }, [getDataType, level]);
+    const fieldNames = (0, import_react.useMemo)(() => {
+      return { title: treeLabelKey, key: treeValueKey, children: treeChildrenKey };
+    }, [treeChildrenKey, treeLabelKey, treeValueKey]);
+    const loop = (0, import_react.useCallback)(
+      (_data, searchValue, parent) => _data.map((item) => {
+        var _a;
+        const index = item[fieldNames.title].indexOf(searchValue);
+        const beforeStr = item[fieldNames.title].substring(0, index);
+        const afterStr = item[fieldNames.title].slice(index + searchValue.length);
+        const title = index > -1 ? /* @__PURE__ */ import_react.default.createElement("span", null, beforeStr, /* @__PURE__ */ import_react.default.createElement("span", { className: b("tree-search-value", false) }, searchValue), afterStr) : /* @__PURE__ */ import_react.default.createElement("span", null, item[fieldNames.title]);
+        const newItem = { ...item, parentId: parent ? [parent.parentId, parent[fieldNames.key]].filter((item1) => !!item1).join(",") : "" };
+        dataList.current.push(newItem);
+        if (((_a = item == null ? void 0 : item[fieldNames.children]) == null ? void 0 : _a.length) > 0) {
+          return {
+            ...item,
+            [fieldNames.title]: title,
+            _title: item[fieldNames.title],
+            [fieldNames.key]: item[fieldNames.key],
+            [fieldNames.children]: loop(item.children, searchValue, newItem).filter((item1) => !!item1),
+            disabled: item.disabled
+          };
+        }
+        return index > -1 ? {
+          ...item,
+          [fieldNames.title]: title,
+          _title: item[fieldNames.title],
+          [fieldNames.key]: item[fieldNames.key],
+          disabled: item.disabled
+        } : null;
+      }),
+      [b, fieldNames.children, fieldNames.key, fieldNames.title]
+    );
+    const expandByKeys = (0, import_react.useCallback)((expandedKeys) => {
+      var _a, _b;
+      const flattenNodes = (_a = treeRef.current) == null ? void 0 : _a.flattenTreeData(expandedKeys);
+      (_b = treeRef.current) == null ? void 0 : _b.setState({
+        expandedKeys,
+        flattenNodes
+      });
+    }, []);
+    const getExpandKeys = (0, import_react.useCallback)(() => {
+      if (isTree) {
+        const _expandedKeys = (0, import_flattenDeep.default)(
+          dataList.current.map((item) => {
+            var _a;
+            if (item[fieldNames.title].indexOf(searchText) > -1) {
+              return ((_a = item.parentId) == null ? void 0 : _a.split(",")) ?? [];
+            }
+            return null;
+          })
+        ).filter((item, i, self) => item && self.indexOf(item) === i);
+        expandByKeys(_expandedKeys);
+      }
+    }, [expandByKeys, fieldNames.title, isTree, searchText]);
+    const scrollToSelected = (0, import_react.useCallback)(() => {
+      var _a, _b;
+      if ((_b = (_a = ulRef.current) == null ? void 0 : _a.resizeRef) == null ? void 0 : _b.current) {
+        const node = ulRef.current.resizeRef.current.querySelectorAll(".in-active-path");
+        if (node && node.length > 0) {
+          setTimeout(() => {
+            (0, import_scroll_into_view_if_needed.default)(node[0], {
+              scrollMode: "if-needed",
+              block: "center"
+            });
+          }, 150);
+        }
+      }
+    }, []);
+    (0, import_react.useEffect)(() => {
+      if (isTree && (0, import_Util.isNotEmpty)(searchText)) {
+        getExpandKeys();
+      }
+    }, [searchText]);
+    (0, import_react.useEffect)(() => {
+      if (isTree) {
+        const expandedKeys = getExpandedKeys(level);
+        expandByKeys(expandedKeys);
+      }
+    }, []);
+    (0, import_react.useImperativeHandle)(ref, () => ({
+      scrollToSelected: () => {
+        scrollToSelected();
+      }
+    }));
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_Scrollbar.Scrollbar,
+      {
+        ref: ulRef,
+        tag: "ul",
+        className: (0, import_classnames.default)(b`menu`, is("list")),
+        wrapClass: be("menu", "wrap"),
+        viewClass: (0, import_classnames.default)(be("menu", "list"), { [b("no-data", false)]: (data == null ? void 0 : data.length) === 0 })
+      },
+      (data == null ? void 0 : data.length) > 0 && data.map((item) => {
+        return /* @__PURE__ */ import_react.default.createElement(
+          "li",
+          {
+            key: item.__id,
+            className: (0, import_classnames.default)(
+              b`node`,
+              { "in-active-path": multiple ? item.__checked || item.__indeterminate : value === item[valueKey] },
+              is({ disabled: item[disabledKey] })
+            ),
+            onClick: () => {
+              if (!item[disabledKey]) {
+                if (menuProps.expandTrigger === "click" || item.__leaf) {
+                  onSelect == null ? void 0 : onSelect(level, item);
+                }
+              }
+            },
+            onMouseEnter: () => {
+              if (menuProps.expandTrigger === "hover" && !item[disabledKey] && !item.__leaf) {
+                onSelect == null ? void 0 : onSelect(level, item);
+              }
+            }
+          },
+          multiple && /* @__PURE__ */ import_react.default.createElement(
+            import_Checkbox.Checkbox,
+            {
+              checked: item.__checked,
+              indeterminate: item.__indeterminate,
+              onChange: (checked) => onCheckedChange == null ? void 0 : onCheckedChange(level, item, checked)
+            }
+          ),
+          /* @__PURE__ */ import_react.default.createElement("span", { className: be("node", "label") }, item[labelKey]),
+          !item.__leaf && loading !== item.__id && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "angle-right", className: be("node", "postfix") }),
+          loading === item.__id && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { prefix: "fas", name: "spinner", spin: true, className: be("node", "postfix") })
+        );
+      }),
+      (data == null ? void 0 : data.length) === 0 && (loading ? "正在加载数据..." : "暂无数据!")
+    );
+  })
+);
+var CascaderMenu_default = CascaderMenu;

package/dist/Cascader/Utils.d.ts

@@ -0,0 +1,3 @@
+import { CascaderMenuProps, OptionNode, TreeMenuProps } from './typings';
+export declare const toArray: (val: string | string[] | string[][], separator?: string) => string[] | string[][];
+export declare const reOrgTree: (treeData: object[], level: number, { valueKey, labelKey, leafKey, childrenKey }: CascaderMenuProps, { valueKey: treeValueKey, labelKey: treeLabelKey, childrenKey: treeChildrenKey }: TreeMenuProps, plainData?: OptionNode[], parent?: any) => OptionNode[];

package/dist/Cascader/Utils.js

@@ -0,0 +1,83 @@
+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/Utils.ts
+var Utils_exports = {};
+__export(Utils_exports, {
+  reOrgTree: () => reOrgTree,
+  toArray: () => toArray
+});
+module.exports = __toCommonJS(Utils_exports);
+var import_cloneDeep = __toESM(require("lodash/cloneDeep"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_Util = require("../Util");
+var toArray = (val, separator = "/") => {
+  if ((0, import_Util.isNotEmpty)(val)) {
+    if (typeof val === "string") {
+      return val.split(separator);
+    } else if (val instanceof Array) {
+      return val;
+    }
+  }
+  return [];
+};
+var reOrgTree = (treeData, level, { valueKey = "value", labelKey = "label", leafKey = "leaf", childrenKey = "children" }, { valueKey: treeValueKey = "key", labelKey: treeLabelKey = "title", childrenKey: treeChildrenKey = "children" }, plainData = [], parent = null) => {
+  return treeData.map((node) => {
+    if (node[childrenKey]) {
+      node[childrenKey] = reOrgTree(
+        node[childrenKey],
+        level,
+        { valueKey, labelKey, leafKey, childrenKey },
+        { valueKey: treeValueKey, labelKey: treeLabelKey, childrenKey: treeChildrenKey },
+        plainData,
+        (0, import_omit.default)((0, import_cloneDeep.default)(node), childrenKey)
+      );
+    }
+    const id = (0, import_Util.randomCode)(11);
+    plainData.push({
+      __id: id,
+      __level: level,
+      __pId: (parent == null ? void 0 : parent.__id) ?? "0",
+      [valueKey]: node[treeValueKey],
+      [labelKey]: node[treeLabelKey],
+      [leafKey]: false,
+      treeChildren: Object.prototype.hasOwnProperty.call(node, treeChildrenKey),
+      ...parent != null ? { parent } : {}
+    });
+    return {
+      ...node,
+      __id: id,
+      __pId: (parent == null ? void 0 : parent.__id) ?? "0"
+    };
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reOrgTree,
+  toArray
+});

package/dist/Cascader/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Cascader } from './Cascader';
+export type { CascaderMenuProps, CascaderProps, TreeMenuProps } from './typings';

package/dist/Cascader/index.js

@@ -0,0 +1,39 @@
+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/index.ts
+var Cascader_exports = {};
+__export(Cascader_exports, {
+  Cascader: () => import_Cascader.default
+});
+module.exports = __toCommonJS(Cascader_exports);
+var import_Cascader = __toESM(require("./Cascader"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cascader
+});

package/dist/Cascader/typings.d.ts

@@ -0,0 +1,79 @@
+import React from 'react';
+import { InputRef } from '../Input';
+import { PopperOptions } from '../Popper';
+import { DataNode, DirectoryTreeProps, Key } from '../Tree';
+import { AnimationEventProps, BaseProps, FormControlBaseProps, NativeProps } from '../types/common';
+export type ValueType = string[] | string[][];
+export interface CascaderProps<V = ValueType, S = DataNode> extends Omit<FormControlBaseProps<V>, 'onChange' | 'value' | 'defaultValue'>, BaseProps, NativeProps, AnimationEventProps, PopperOptions, Omit<DirectoryTreeProps<S>, 'children' | 'style' | 'expandedKeys' | 'className' | 'readOnly' | 'disabled'> {
+    defaultValue?: ValueType;
+    value?: ValueType;
+    options?: any[];
+    props?: CascaderMenuProps;
+    treeMenuProps?: TreeMenuProps;
+    disabled?: boolean;
+    clearable?: boolean;
+    showAllLevels?: boolean;
+    separator?: string;
+    filterable?: boolean;
+    filterMethod?: (val: ValueType, searchText: string) => boolean;
+    placeholder?: string;
+    noDataText?: string;
+    noMatchText?: string;
+    loading?: boolean;
+    loadingText?: string;
+    required?: boolean;
+    error?: boolean;
+    warning?: boolean;
+    collapseTags?: boolean;
+    maxCollapseTags?: number;
+    collapseTagsTooltip?: boolean;
+    collapseTips?: (collapseNum: number, total: number) => string;
+    plain?: boolean;
+    prefix?: React.ReactElement<any> | string | number;
+    suffix?: React.ReactElement<any> | string | number;
+    prepend?: React.ReactElement<any> | string | number;
+    append?: React.ReactElement | string | number;
+    expandedKeys?: Key[][];
+    lable?: string;
+    appendToBody?: boolean;
+    onChange?: (value: ValueType, level?: number, label?: string | string[], node?: S[] | S[][]) => void;
+    shouldSelect?: (node?: object, level?: number) => boolean;
+    labelFormatter?: (level?: number, node?: object[]) => string;
+}
+export interface CascaderMenuProps {
+    expandTrigger?: 'click' | 'hover';
+    multiple?: boolean;
+    checkStrictly?: boolean;
+    emitPath?: boolean;
+    lazy?: boolean;
+    lazyLoad?: (node: object, resolve?: (value: object[], isTree?: boolean) => void, reject?: () => void) => void;
+    valueKey?: string;
+    labelKey?: string;
+    childrenKey?: string;
+    disabledKey?: string;
+    leafKey?: string;
+}
+export interface TreeMenuProps {
+    valueKey?: string;
+    labelKey?: string;
+    childrenKey?: string;
+    disabledKey?: string;
+    leafKey?: string;
+}
+export interface CascaderRef {
+    inputInstance?: InputRef;
+    setLabel: (label: string) => void;
+    onClear: () => void;
+    resetNodes: () => void;
+    setVisible: (visible: boolean) => void;
+}
+export interface OptionNode extends Object {
+    __id: string;
+    __pId: string;
+    __level?: number;
+    __leaf?: boolean;
+    __checked?: boolean;
+    __indeterminate?: boolean;
+    children?: OptionNode[];
+    treeChildren?: boolean;
+}

package/dist/Cascader/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Cascader/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Cascader/useCascader.d.ts

@@ -0,0 +1,30 @@
+import { Key } from '../Tree';
+import { CascaderProps, OptionNode } from './typings';
+export declare const useCascader: (initialData: object[], props: CascaderProps, value: string[] | string[][]) => {
+    allLevel: number;
+    optionData: Record<string, OptionNode[]>;
+    storeOptionData: (nodes: object[], level: number, parent: OptionNode, { isTree, isCover }: {
+        isTree?: boolean;
+        isCover?: boolean;
+    }) => OptionNode[];
+    getSelectedValue: () => string[];
+    getValueOfLevel: (level?: number) => string;
+    getSelectedLabel: (labelFormatter?: (node?: OptionNode[]) => string) => string;
+    setSelectedNode: (level: number, node: OptionNode) => void;
+    setSelectedValue: (level: number, val: string) => void;
+    getSelectedNode: () => OptionNode[];
+    setCheckedNode: (level: number, node: OptionNode, checked: boolean) => void;
+    getCheckedNodes: () => OptionNode[][];
+    getCheckedValue: () => string[][];
+    getCheckedLabel: () => any[][];
+    loopGetParent: (level: number, node: OptionNode, result?: OptionNode[]) => OptionNode[];
+    getOptions: (level: number) => OptionNode[];
+    clearSelected: () => void;
+    setNodeLeaf: (node: OptionNode, isLeaf: boolean) => void;
+    getDataType: (level: number) => any;
+    getTreeData: (level: number) => any[];
+    getExpandedKeys: (level: number) => Key[];
+    setExpandedKeys: (level: number, keys: Key[]) => void;
+    handleSearch: (searchText: string) => OptionNode[][];
+    resetNodes: () => void;
+};