@yh-ui/components 0.1.0

package/dist/cascader/__tests__/cascader.test.cjs

@@ -0,0 +1,342 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _testUtils = require("@vue/test-utils");
+var _vue = require("vue");
+var _cascader = _interopRequireDefault(require("../src/cascader.vue"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("YhCascader", () => {
+  const options = [{
+    value: "guide",
+    label: "\u6307\u5357",
+    children: [{
+      value: "design",
+      label: "\u8BBE\u8BA1\u539F\u5219",
+      children: [{
+        value: "consistency",
+        label: "\u4E00\u81F4"
+      }, {
+        value: "feedback",
+        label: "\u53CD\u9988"
+      }]
+    }, {
+      value: "navigation",
+      label: "\u5BFC\u822A",
+      children: [{
+        value: "side-nav",
+        label: "\u4FA7\u5411\u5BFC\u822A"
+      }, {
+        value: "top-nav",
+        label: "\u9876\u90E8\u5BFC\u822A"
+      }]
+    }]
+  }, {
+    value: "component",
+    label: "\u7EC4\u4EF6",
+    children: [{
+      value: "basic",
+      label: "\u57FA\u7840\u7EC4\u4EF6",
+      children: [{
+        value: "button",
+        label: "Button \u6309\u94AE"
+      }, {
+        value: "icon",
+        label: "Icon \u56FE\u6807"
+      }]
+    }]
+  }, {
+    value: "resource",
+    label: "\u8D44\u6E90",
+    disabled: true,
+    children: [{
+      value: "axure",
+      label: "Axure Components"
+    }]
+  }];
+  (0, _vitest.it)("should render correctly", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-cascader");
+    (0, _vitest.expect)(wrapper.find("input").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should work with v-model", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        "onUpdate:modelValue": val => wrapper.setProps({
+          modelValue: val
+        })
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-cascader__selected-value").text()).toContain("\u6307\u5357");
+  });
+  (0, _vitest.it)("should display placeholder when no value", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        placeholder: "\u8BF7\u9009\u62E9"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find("input").attributes("placeholder")).toBe("\u8BF7\u9009\u62E9");
+  });
+  (0, _vitest.it)("should be disabled when disabled prop is true", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        disabled: true
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-disabled");
+    (0, _vitest.expect)(wrapper.find("input").attributes("disabled")).toBeDefined();
+  });
+  (0, _vitest.it)("should apply size class", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        size: "large"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-cascader--large");
+  });
+  (0, _vitest.it)("should apply small size class", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        size: "small"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-cascader--small");
+  });
+  (0, _vitest.it)("should show clear button when clearable and has value", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        clearable: true
+      }
+    });
+    await wrapper.trigger("mouseenter");
+    await wrapper.find("input").trigger("focus");
+    await (0, _vue.nextTick)();
+    (0, _vitest.expect)(wrapper.find(".yh-cascader__clear").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should clear value when clear button is clicked", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        clearable: true,
+        "onUpdate:modelValue": val => wrapper.setProps({
+          modelValue: val
+        })
+      }
+    });
+    await wrapper.trigger("mouseenter");
+    await wrapper.find("input").trigger("focus");
+    await (0, _vue.nextTick)();
+    await wrapper.find(".yh-cascader__clear").trigger("click");
+    (0, _vitest.expect)(wrapper.emitted("clear")).toBeTruthy();
+    (0, _vitest.expect)(wrapper.props("modelValue")).toEqual([]);
+  });
+  (0, _vitest.it)("should toggle dropdown on click", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options
+      }
+    });
+    await wrapper.trigger("click");
+    (0, _vitest.expect)(wrapper.emitted("visible-change")).toBeTruthy();
+    (0, _vitest.expect)(wrapper.emitted("visible-change")[0]).toEqual([true]);
+  });
+  (0, _vitest.it)("should show only last level when showAllLevels is false", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        showAllLevels: false
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-cascader__selected-value").text()).toBe("\u4E00\u81F4");
+  });
+  (0, _vitest.it)("should show full path when showAllLevels is true", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        showAllLevels: true,
+        separator: " / "
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-cascader__selected-value").text()).toContain("/");
+  });
+  (0, _vitest.it)("should work in multiple mode", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        props: {
+          multiple: true
+        },
+        modelValue: [["guide", "design", "consistency"], ["guide", "design", "feedback"]],
+        "onUpdate:modelValue": val => wrapper.setProps({
+          modelValue: val
+        })
+      }
+    });
+    const tags = wrapper.findAll(".yh-cascader__tag");
+    (0, _vitest.expect)(tags.length).toBe(2);
+  });
+  (0, _vitest.it)("should collapse tags when collapseTags is true", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        props: {
+          multiple: true
+        },
+        modelValue: [["guide", "design", "consistency"], ["guide", "design", "feedback"], ["component", "basic", "button"]],
+        collapseTags: true,
+        maxCollapseTags: 1
+      }
+    });
+    const tags = wrapper.findAll(".yh-cascader__tag");
+    (0, _vitest.expect)(tags.length).toBe(2);
+    (0, _vitest.expect)(tags[1].text()).toContain("+2");
+  });
+  (0, _vitest.it)("should remove tag in multiple mode", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        props: {
+          multiple: true
+        },
+        modelValue: [["guide", "design", "consistency"], ["guide", "design", "feedback"]],
+        "onUpdate:modelValue": val => wrapper.setProps({
+          modelValue: val
+        })
+      }
+    });
+    const closeBtn = wrapper.find(".yh-cascader__tag-close");
+    if (closeBtn.exists()) {
+      await closeBtn.trigger("click");
+      (0, _vitest.expect)(wrapper.emitted("change")).toBeTruthy();
+    }
+  });
+  (0, _vitest.it)("should filter options when filterable", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        filterable: true
+      }
+    });
+    await wrapper.trigger("click");
+    await wrapper.find("input").setValue("\u6309\u94AE");
+    await (0, _vue.nextTick)();
+    (0, _vitest.expect)(wrapper.emitted()).toBeTruthy();
+  });
+  (0, _vitest.it)("should use custom separator", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        separator: " > "
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-cascader__selected-value").text()).toContain(">");
+  });
+  (0, _vitest.it)("should emit focus and blur events", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options
+      }
+    });
+    await wrapper.find("input").trigger("focus");
+    (0, _vitest.expect)(wrapper.emitted("focus")).toBeTruthy();
+    await wrapper.find("input").trigger("blur");
+    await new Promise(resolve => setTimeout(resolve, 200));
+    (0, _vitest.expect)(wrapper.emitted("blur")).toBeTruthy();
+  });
+  (0, _vitest.it)("should have correct ARIA attributes", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options
+      }
+    });
+    const input = wrapper.find("input");
+    (0, _vitest.expect)(input.attributes("role")).toBe("combobox");
+    (0, _vitest.expect)(input.attributes("aria-expanded")).toBeDefined();
+  });
+  (0, _vitest.it)("should expose focus, blur and getCheckedNodes methods", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options
+      }
+    });
+    const vm = wrapper.vm;
+    (0, _vitest.expect)(typeof vm.focus).toBe("function");
+    (0, _vitest.expect)(typeof vm.blur).toBe("function");
+    (0, _vitest.expect)(typeof vm.getCheckedNodes).toBe("function");
+  });
+  (0, _vitest.it)("should return checked nodes", () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"]
+      }
+    });
+    const vm = wrapper.vm;
+    const nodes = vm.getCheckedNodes();
+    (0, _vitest.expect)(nodes.length).toBe(1);
+    (0, _vitest.expect)(nodes[0].value).toBe("consistency");
+  });
+  (0, _vitest.it)("should not select disabled option", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        "onUpdate:modelValue": val => wrapper.setProps({
+          modelValue: val
+        })
+      }
+    });
+    await wrapper.trigger("click");
+    await (0, _vue.nextTick)();
+    const disabledOption = wrapper.find(".yh-cascader__node.is-disabled");
+    if (disabledOption.exists()) {
+      await disabledOption.trigger("click");
+      (0, _vitest.expect)(wrapper.props("modelValue")).toBeUndefined();
+    }
+  });
+  (0, _vitest.it)("should emit expand-change when expanding", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options
+      }
+    });
+    await wrapper.trigger("click");
+    await (0, _vue.nextTick)();
+    const firstOption = wrapper.find(".yh-cascader__node");
+    if (firstOption.exists()) {
+      await firstOption.trigger("click");
+      (0, _vitest.expect)(wrapper.emitted("expand-change")).toBeTruthy();
+    }
+  });
+  (0, _vitest.it)("should expand on hover when expandTrigger is hover", async () => {
+    const wrapper = (0, _testUtils.mount)(_cascader.default, {
+      props: {
+        options,
+        props: {
+          expandTrigger: "hover"
+        }
+      }
+    });
+    await wrapper.trigger("click");
+    await (0, _vue.nextTick)();
+    const firstOption = wrapper.find(".yh-cascader__node");
+    if (firstOption.exists()) {
+      await firstOption.trigger("mouseenter");
+      (0, _vitest.expect)(wrapper.emitted("expand-change")).toBeTruthy();
+    }
+  });
+});

package/dist/cascader/__tests__/cascader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cascader/__tests__/cascader.test.mjs

@@ -0,0 +1,316 @@
+import { describe, it, expect } from "vitest";
+import { mount } from "@vue/test-utils";
+import { nextTick } from "vue";
+import Cascader from "../src/cascader.vue";
+describe("YhCascader", () => {
+  const options = [
+    {
+      value: "guide",
+      label: "\u6307\u5357",
+      children: [
+        {
+          value: "design",
+          label: "\u8BBE\u8BA1\u539F\u5219",
+          children: [
+            { value: "consistency", label: "\u4E00\u81F4" },
+            { value: "feedback", label: "\u53CD\u9988" }
+          ]
+        },
+        {
+          value: "navigation",
+          label: "\u5BFC\u822A",
+          children: [
+            { value: "side-nav", label: "\u4FA7\u5411\u5BFC\u822A" },
+            { value: "top-nav", label: "\u9876\u90E8\u5BFC\u822A" }
+          ]
+        }
+      ]
+    },
+    {
+      value: "component",
+      label: "\u7EC4\u4EF6",
+      children: [
+        {
+          value: "basic",
+          label: "\u57FA\u7840\u7EC4\u4EF6",
+          children: [
+            { value: "button", label: "Button \u6309\u94AE" },
+            { value: "icon", label: "Icon \u56FE\u6807" }
+          ]
+        }
+      ]
+    },
+    {
+      value: "resource",
+      label: "\u8D44\u6E90",
+      disabled: true,
+      children: [{ value: "axure", label: "Axure Components" }]
+    }
+  ];
+  it("should render correctly", () => {
+    const wrapper = mount(Cascader, {
+      props: { options }
+    });
+    expect(wrapper.classes()).toContain("yh-cascader");
+    expect(wrapper.find("input").exists()).toBe(true);
+  });
+  it("should work with v-model", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        "onUpdate:modelValue": (val) => wrapper.setProps({ modelValue: val })
+      }
+    });
+    expect(wrapper.find(".yh-cascader__selected-value").text()).toContain("\u6307\u5357");
+  });
+  it("should display placeholder when no value", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        placeholder: "\u8BF7\u9009\u62E9"
+      }
+    });
+    expect(wrapper.find("input").attributes("placeholder")).toBe("\u8BF7\u9009\u62E9");
+  });
+  it("should be disabled when disabled prop is true", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        disabled: true
+      }
+    });
+    expect(wrapper.classes()).toContain("is-disabled");
+    expect(wrapper.find("input").attributes("disabled")).toBeDefined();
+  });
+  it("should apply size class", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        size: "large"
+      }
+    });
+    expect(wrapper.classes()).toContain("yh-cascader--large");
+  });
+  it("should apply small size class", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        size: "small"
+      }
+    });
+    expect(wrapper.classes()).toContain("yh-cascader--small");
+  });
+  it("should show clear button when clearable and has value", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        clearable: true
+      }
+    });
+    await wrapper.trigger("mouseenter");
+    await wrapper.find("input").trigger("focus");
+    await nextTick();
+    expect(wrapper.find(".yh-cascader__clear").exists()).toBe(true);
+  });
+  it("should clear value when clear button is clicked", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        clearable: true,
+        "onUpdate:modelValue": (val) => wrapper.setProps({ modelValue: val })
+      }
+    });
+    await wrapper.trigger("mouseenter");
+    await wrapper.find("input").trigger("focus");
+    await nextTick();
+    await wrapper.find(".yh-cascader__clear").trigger("click");
+    expect(wrapper.emitted("clear")).toBeTruthy();
+    expect(wrapper.props("modelValue")).toEqual([]);
+  });
+  it("should toggle dropdown on click", async () => {
+    const wrapper = mount(Cascader, {
+      props: { options }
+    });
+    await wrapper.trigger("click");
+    expect(wrapper.emitted("visible-change")).toBeTruthy();
+    expect(wrapper.emitted("visible-change")[0]).toEqual([true]);
+  });
+  it("should show only last level when showAllLevels is false", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        showAllLevels: false
+      }
+    });
+    expect(wrapper.find(".yh-cascader__selected-value").text()).toBe("\u4E00\u81F4");
+  });
+  it("should show full path when showAllLevels is true", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        showAllLevels: true,
+        separator: " / "
+      }
+    });
+    expect(wrapper.find(".yh-cascader__selected-value").text()).toContain("/");
+  });
+  it("should work in multiple mode", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        props: { multiple: true },
+        modelValue: [
+          ["guide", "design", "consistency"],
+          ["guide", "design", "feedback"]
+        ],
+        "onUpdate:modelValue": (val) => wrapper.setProps({ modelValue: val })
+      }
+    });
+    const tags = wrapper.findAll(".yh-cascader__tag");
+    expect(tags.length).toBe(2);
+  });
+  it("should collapse tags when collapseTags is true", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        props: { multiple: true },
+        modelValue: [
+          ["guide", "design", "consistency"],
+          ["guide", "design", "feedback"],
+          ["component", "basic", "button"]
+        ],
+        collapseTags: true,
+        maxCollapseTags: 1
+      }
+    });
+    const tags = wrapper.findAll(".yh-cascader__tag");
+    expect(tags.length).toBe(2);
+    expect(tags[1].text()).toContain("+2");
+  });
+  it("should remove tag in multiple mode", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        props: { multiple: true },
+        modelValue: [
+          ["guide", "design", "consistency"],
+          ["guide", "design", "feedback"]
+        ],
+        "onUpdate:modelValue": (val) => wrapper.setProps({ modelValue: val })
+      }
+    });
+    const closeBtn = wrapper.find(".yh-cascader__tag-close");
+    if (closeBtn.exists()) {
+      await closeBtn.trigger("click");
+      expect(wrapper.emitted("change")).toBeTruthy();
+    }
+  });
+  it("should filter options when filterable", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        filterable: true
+      }
+    });
+    await wrapper.trigger("click");
+    await wrapper.find("input").setValue("\u6309\u94AE");
+    await nextTick();
+    expect(wrapper.emitted()).toBeTruthy();
+  });
+  it("should use custom separator", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"],
+        separator: " > "
+      }
+    });
+    expect(wrapper.find(".yh-cascader__selected-value").text()).toContain(">");
+  });
+  it("should emit focus and blur events", async () => {
+    const wrapper = mount(Cascader, {
+      props: { options }
+    });
+    await wrapper.find("input").trigger("focus");
+    expect(wrapper.emitted("focus")).toBeTruthy();
+    await wrapper.find("input").trigger("blur");
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    expect(wrapper.emitted("blur")).toBeTruthy();
+  });
+  it("should have correct ARIA attributes", () => {
+    const wrapper = mount(Cascader, {
+      props: { options }
+    });
+    const input = wrapper.find("input");
+    expect(input.attributes("role")).toBe("combobox");
+    expect(input.attributes("aria-expanded")).toBeDefined();
+  });
+  it("should expose focus, blur and getCheckedNodes methods", () => {
+    const wrapper = mount(Cascader, {
+      props: { options }
+    });
+    const vm = wrapper.vm;
+    expect(typeof vm.focus).toBe("function");
+    expect(typeof vm.blur).toBe("function");
+    expect(typeof vm.getCheckedNodes).toBe("function");
+  });
+  it("should return checked nodes", () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        modelValue: ["guide", "design", "consistency"]
+      }
+    });
+    const vm = wrapper.vm;
+    const nodes = vm.getCheckedNodes();
+    expect(nodes.length).toBe(1);
+    expect(nodes[0].value).toBe("consistency");
+  });
+  it("should not select disabled option", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        "onUpdate:modelValue": (val) => wrapper.setProps({ modelValue: val })
+      }
+    });
+    await wrapper.trigger("click");
+    await nextTick();
+    const disabledOption = wrapper.find(".yh-cascader__node.is-disabled");
+    if (disabledOption.exists()) {
+      await disabledOption.trigger("click");
+      expect(wrapper.props("modelValue")).toBeUndefined();
+    }
+  });
+  it("should emit expand-change when expanding", async () => {
+    const wrapper = mount(Cascader, {
+      props: { options }
+    });
+    await wrapper.trigger("click");
+    await nextTick();
+    const firstOption = wrapper.find(".yh-cascader__node");
+    if (firstOption.exists()) {
+      await firstOption.trigger("click");
+      expect(wrapper.emitted("expand-change")).toBeTruthy();
+    }
+  });
+  it("should expand on hover when expandTrigger is hover", async () => {
+    const wrapper = mount(Cascader, {
+      props: {
+        options,
+        props: { expandTrigger: "hover" }
+      }
+    });
+    await wrapper.trigger("click");
+    await nextTick();
+    const firstOption = wrapper.find(".yh-cascader__node");
+    if (firstOption.exists()) {
+      await firstOption.trigger("mouseenter");
+      expect(wrapper.emitted("expand-change")).toBeTruthy();
+    }
+  });
+});

package/dist/cascader/index.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  YhCascader: true,
+  YhCascaderPanel: true
+};
+module.exports = exports.YhCascaderPanel = exports.YhCascader = void 0;
+var _utils = require("@yh-ui/utils");
+var _cascader = _interopRequireDefault(require("./src/cascader.vue"));
+var _cascaderPanel = _interopRequireDefault(require("./src/cascader-panel.vue"));
+var _cascader2 = require("./src/cascader.cjs");
+Object.keys(_cascader2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _cascader2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cascader2[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const YhCascader = exports.YhCascader = (0, _utils.withInstall)(_cascader.default);
+const YhCascaderPanel = exports.YhCascaderPanel = (0, _utils.withInstall)(_cascaderPanel.default);
+module.exports = YhCascader;

package/dist/cascader/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Cascader Component
+ * @description 级联选择器组件导出
+ */
+import Cascader from './src/cascader.vue';
+import CascaderPanel from './src/cascader-panel.vue';
+export declare const YhCascader: any;
+export declare const YhCascaderPanel: any;
+export default YhCascader;
+export * from './src/cascader';
+export type CascaderInstance = InstanceType<typeof Cascader>;
+export type CascaderPanelInstance = InstanceType<typeof CascaderPanel>;