ep-craft 0.1.34 → 0.1.35

package/dist/components/cascader-panel/EpCascaderMenu.vue.js

@@ -0,0 +1,204 @@
+import { defineComponent as Q, getCurrentInstance as U, inject as ee, ref as V, computed as L, openBlock as d, createElementBlock as m, normalizeClass as c, unref as e, createVNode as y, withCtx as E, createBlock as z, normalizeStyle as te, createTextVNode as I, toDisplayString as T, renderSlot as b, createCommentVNode as P, Fragment as oe, renderList as ne, nextTick as se } from "vue";
+import { clamp as q } from "lodash-unified";
+import { EpScrollbar as le } from "../scrollbar/index.js";
+import ie from "../virtual-list/src/components/fixed-size-list.js";
+import "../virtual-list/src/components/dynamic-size-list.js";
+import "../virtual-list/src/props.js";
+import { useNamespace as re } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "@vueuse/core";
+import { focusNode as ae } from "../../utils/dom/aria.js";
+import { Loading as F } from "@element-plus/icons-vue";
+import { useLocale as de } from "../../hooks/use-locale/index.js";
+import { useId as ce } from "../../hooks/use-id/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import { EpIcon as O } from "../icon/index.js";
+import X from "./EpCascaderNode.vue.js";
+import { CASCADER_PANEL_INJECTION_KEY as ue } from "./types.js";
+import { CASCADER_PANEL_HEIGHT as me, CASCADER_PANEL_ITEM_SIZE as pe } from "./config.js";
+const Re = /* @__PURE__ */ Q({
+  name: "EpCascaderMenu",
+  __name: "EpCascaderMenu",
+  props: {
+    nodes: {},
+    index: {},
+    virtualScroll: { type: Boolean, default: !1 },
+    itemSize: { default: pe },
+    height: { default: me }
+  },
+  setup(p, { expose: j }) {
+    const n = p, M = U(), o = re("cascader-menu"), { t: x } = de(), G = ce();
+    let h, g;
+    const r = ee(ue), f = V(), N = V(), k = L(() => !n.nodes.length), A = L(() => !r.initialLoaded), v = L(() => `${G.value}-${n.index}`), J = () => {
+      var i, s, l, a;
+      let t;
+      if (r.expandingNode) {
+        const { level: u, pathNodes: $ } = r.expandingNode;
+        n.index < u ? t = (i = $[n.index]) == null ? void 0 : i.uid : n.index === u && r.checkedNodes.length > 0 && (t = (l = (s = r.checkedNodes[0]) == null ? void 0 : s.pathNodes[n.index]) == null ? void 0 : l.uid);
+      } else r.checkedNodes.length > 0 && n.index < r.checkedNodes[0].pathNodes.length && (t = (a = r.checkedNodes[0].pathNodes[n.index]) == null ? void 0 : a.uid);
+      return t !== void 0 ? n.nodes.findIndex((u) => u.uid === t) : -1;
+    }, K = (t) => t ? n.nodes.findIndex(
+      (i) => `${v.value}-${i.uid}` === t
+    ) : -1, H = (t) => {
+      var s;
+      const i = q(t, 0, n.nodes.length - 1);
+      (s = N.value) == null || s.scrollToItem(i);
+    }, W = (t) => {
+      if (!n.nodes.length) return;
+      const i = q(t, 0, n.nodes.length - 1);
+      H(i), se(() => {
+        var l;
+        const s = (l = M.vnode.el) == null ? void 0 : l.querySelector(
+          `#${v.value}-${n.nodes[i].uid}`
+        );
+        s && ae(s);
+      });
+    }, w = (t) => {
+      h = t.target;
+    }, _ = (t) => {
+      var i, s, l;
+      if (!(!r.isHoverMenu || !h || !f.value))
+        if (h.contains(t.target)) {
+          Z();
+          const a = M.vnode.el, { left: u } = a.getBoundingClientRect(), { offsetWidth: $, offsetHeight: Y } = a, B = t.clientX - u, C = h.offsetTop, D = C + h.offsetHeight, R = n.virtualScroll ? ((s = (i = N.value) == null ? void 0 : i.states) == null ? void 0 : s.scrollOffset) || 0 : ((l = a.querySelector(`.${o.e("wrap")}`)) == null ? void 0 : l.scrollTop) || 0;
+          f.value.innerHTML = `
+          <path style="pointer-events: auto;" fill="transparent" d="M${B} ${C} L${$} ${R} V${C} Z" />
+          <path style="pointer-events: auto;" fill="transparent" d="M${B} ${D} L${$} ${Y + R} V${D} Z" />
+        `;
+        } else g || (g = window.setTimeout(S, r.config.hoverThreshold));
+    }, Z = () => {
+      g && (clearTimeout(g), g = void 0);
+    }, S = () => {
+      f.value && (f.value.innerHTML = "", Z());
+    };
+    return j({
+      getActiveNodeIndex: J,
+      getNodeIndexById: K,
+      scrollToItem: H,
+      focusNodeAt: W,
+      virtualListRef: N,
+      get $el() {
+        return M.vnode.el;
+      }
+    }), (t, i) => {
+      var s;
+      return p.virtualScroll ? (d(), m("div", {
+        key: v.value,
+        class: c(e(o).b()),
+        onMousemove: _,
+        onMouseleave: S
+      }, [
+        y(e(ie), {
+          ref_key: "virtualListRef",
+          ref: N,
+          height: p.height,
+          "item-size": p.itemSize,
+          data: p.nodes,
+          total: p.nodes.length,
+          "class-name": e(o).e("list"),
+          "inner-element": "ul",
+          "inner-props": {
+            role: "menu",
+            class: e(o).is("empty", k.value)
+          }
+        }, {
+          default: E(({ data: l, index: a, style: u }) => [
+            (d(), z(X, {
+              key: l[a].uid,
+              node: l[a],
+              "menu-id": v.value,
+              style: te(u),
+              onExpand: w
+            }, null, 8, ["node", "menu-id", "style"]))
+          ]),
+          _: 1
+        }, 8, ["height", "item-size", "data", "total", "class-name", "inner-props"]),
+        A.value ? (d(), m("div", {
+          key: 0,
+          class: c(e(o).e("empty-text"))
+        }, [
+          y(e(O), {
+            size: 14,
+            class: c(e(o).is("loading"))
+          }, {
+            default: E(() => [
+              y(e(F))
+            ]),
+            _: 1
+          }, 8, ["class"]),
+          I(" " + T(e(x)("el.cascader.loading")), 1)
+        ], 2)) : k.value ? (d(), m("div", {
+          key: 1,
+          class: c(e(o).e("empty-text"))
+        }, [
+          b(t.$slots, "empty", {}, () => [
+            I(T(e(x)("el.cascader.noData")), 1)
+          ])
+        ], 2)) : (s = e(r)) != null && s.isHoverMenu ? (d(), m("svg", {
+          key: 2,
+          ref_key: "hoverZone",
+          ref: f,
+          class: c(e(o).e("hover-zone"))
+        }, null, 2)) : P("", !0)
+      ], 34)) : (d(), z(e(le), {
+        key: v.value,
+        tag: "ul",
+        role: "menu",
+        class: c(e(o).b()),
+        "wrap-class": e(o).e("wrap"),
+        "view-class": [e(o).e("list"), e(o).is("empty", k.value)],
+        onMousemove: _,
+        onMouseleave: S
+      }, {
+        default: E(() => {
+          var l;
+          return [
+            (d(!0), m(oe, null, ne(p.nodes, (a) => (d(), z(X, {
+              key: a.uid,
+              node: a,
+              "menu-id": v.value,
+              onExpand: w
+            }, null, 8, ["node", "menu-id"]))), 128)),
+            A.value ? (d(), m("div", {
+              key: 0,
+              class: c(e(o).e("empty-text"))
+            }, [
+              y(e(O), {
+                size: 14,
+                class: c(e(o).is("loading"))
+              }, {
+                default: E(() => [
+                  y(e(F))
+                ]),
+                _: 1
+              }, 8, ["class"]),
+              I(" " + T(e(x)("el.cascader.loading")), 1)
+            ], 2)) : k.value ? (d(), m("div", {
+              key: 1,
+              class: c(e(o).e("empty-text"))
+            }, [
+              b(t.$slots, "empty", {}, () => [
+                I(T(e(x)("el.cascader.noData")), 1)
+              ])
+            ], 2)) : (l = e(r)) != null && l.isHoverMenu ? (d(), m("svg", {
+              key: 2,
+              ref_key: "hoverZone",
+              ref: f,
+              class: c(e(o).e("hover-zone"))
+            }, null, 2)) : P("", !0)
+          ];
+        }),
+        _: 3
+      }, 8, ["class", "wrap-class", "view-class"]));
+    };
+  }
+});
+export {
+  Re as default
+};

package/dist/components/cascader-panel/EpCascaderMenu2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpCascaderMenu.vue.js";
+export {
+  f as default
+};

package/dist/components/cascader-panel/EpCascaderNode.vue.d.ts

@@ -0,0 +1,11 @@
+import type { CascaderNode } from './types';
+type __VLS_Props = {
+    node: CascaderNode;
+    menuId?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    expand: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onExpand?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/cascader-panel/EpCascaderNode.vue.js

@@ -0,0 +1,134 @@
+import { defineComponent as U, inject as $, computed as i, openBlock as u, createElementBlock as M, normalizeClass as p, unref as a, createBlock as m, withModifiers as S, withCtx as f, createElementVNode as j, createVNode as h, createCommentVNode as B, Fragment as J } from "vue";
+import { EpCheckbox as K } from "../checkbox/index.js";
+import { EpRadio as T } from "../radio/index.js";
+import { EpIcon as E } from "../icon/index.js";
+import { useNamespace as Y } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { Check as q, Loading as G, ArrowRight as Q } from "@element-plus/icons-vue";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import W from "./node-content.js";
+import { CASCADER_PANEL_INJECTION_KEY as X } from "./types.js";
+const Z = ["id", "aria-haspopup", "aria-owns", "aria-expanded", "tabindex"], ke = /* @__PURE__ */ U({
+  name: "EpCascaderNode",
+  __name: "EpCascaderNode",
+  props: {
+    node: {},
+    menuId: {}
+  },
+  emits: ["expand"],
+  setup(n, { emit: D }) {
+    const l = n, H = D, o = $(X), c = Y("cascader-node"), b = i(() => o.isHoverMenu), k = i(() => o.config.multiple), s = i(() => o.config.checkStrictly), g = i(() => o.config.showPrefix), O = i(() => {
+      var e;
+      return (e = o.checkedNodes[0]) == null ? void 0 : e.uid;
+    }), r = i(() => l.node.isDisabled), t = i(() => l.node.isLeaf), C = i(
+      () => s.value && !t.value || !r.value
+    ), x = i(() => y(o.expandingNode)), R = i(
+      () => s.value && o.checkedNodes.some(y)
+    ), y = (e) => {
+      var A;
+      const { level: d, uid: F } = l.node;
+      return ((A = e == null ? void 0 : e.pathNodes[d - 1]) == null ? void 0 : A.uid) === F;
+    }, v = () => {
+      x.value || o.expandNode(l.node);
+    }, w = (e) => {
+      const { node: d } = l;
+      e !== d.checked && o.handleCheckChange(d, e);
+    }, I = () => {
+      o.lazyLoad(l.node, () => {
+        t.value || v();
+      });
+    }, L = (e) => {
+      b.value && (P(), !t.value && H("expand", e));
+    }, P = () => {
+      const { node: e } = l;
+      !C.value || e.loading || (e.loaded ? v() : I());
+    }, z = () => {
+      t.value && !r.value && !s.value && !k.value ? V(!0) : (o.config.checkOnClickNode && (k.value || s.value) || t.value && o.config.checkOnClickLeaf) && !r.value ? N(!l.node.checked) : b.value || P();
+    }, N = (e) => {
+      s.value ? (w(e), l.node.loaded && v()) : V(e);
+    }, V = (e) => {
+      l.node.loaded ? (w(e), !s.value && v()) : I();
+    };
+    return (e, d) => (u(), M("li", {
+      id: `${n.menuId}-${n.node.uid}`,
+      role: "menuitem",
+      "aria-haspopup": !t.value,
+      "aria-owns": t.value ? void 0 : n.menuId,
+      "aria-expanded": x.value,
+      tabindex: C.value ? -1 : void 0,
+      class: p([
+        a(c).b(),
+        a(c).is("selectable", s.value),
+        a(c).is("active", n.node.checked),
+        a(c).is("disabled", !C.value),
+        x.value && "in-active-path",
+        R.value && "in-checked-path"
+      ]),
+      onMouseenter: L,
+      onFocus: L,
+      onClick: z
+    }, [
+      k.value && g.value ? (u(), m(a(K), {
+        key: 0,
+        "model-value": n.node.checked,
+        indeterminate: n.node.indeterminate,
+        disabled: r.value,
+        onClick: d[0] || (d[0] = S(() => {
+        }, ["stop"])),
+        "onUpdate:modelValue": N
+      }, null, 8, ["model-value", "indeterminate", "disabled"])) : s.value && g.value ? (u(), m(a(T), {
+        key: 1,
+        "model-value": O.value,
+        label: n.node.uid,
+        disabled: r.value,
+        "onUpdate:modelValue": N,
+        onClick: d[1] || (d[1] = S(() => {
+        }, ["stop"]))
+      }, {
+        default: f(() => [...d[2] || (d[2] = [
+          j("span", null, null, -1)
+        ])]),
+        _: 1
+      }, 8, ["model-value", "label", "disabled"])) : t.value && n.node.checked ? (u(), m(a(E), {
+        key: 2,
+        class: p(a(c).e("prefix"))
+      }, {
+        default: f(() => [
+          h(a(q))
+        ]),
+        _: 1
+      }, 8, ["class"])) : B("", !0),
+      h(a(W), { node: n.node }, null, 8, ["node"]),
+      t.value ? B("", !0) : (u(), M(J, { key: 3 }, [
+        n.node.loading ? (u(), m(a(E), {
+          key: 0,
+          class: p([a(c).is("loading"), a(c).e("postfix")])
+        }, {
+          default: f(() => [
+            h(a(G))
+          ]),
+          _: 1
+        }, 8, ["class"])) : (u(), m(a(E), {
+          key: 1,
+          class: p(["arrow-right", a(c).e("postfix")])
+        }, {
+          default: f(() => [
+            h(a(Q))
+          ]),
+          _: 1
+        }, 8, ["class"]))
+      ], 64))
+    ], 42, Z));
+  }
+});
+export {
+  ke as default
+};

package/dist/components/cascader-panel/EpCascaderNode2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpCascaderNode.vue.js";
+export {
+  f as default
+};

package/dist/components/cascader-panel/EpCascaderPanel.vue.d.ts

@@ -0,0 +1,290 @@
+import Node from './node';
+import type { CascaderNode, CascaderNodeValue, CascaderOption, CascaderValue } from './types';
+import type { CascaderMenuInstance } from './instance';
+import type { CascaderPanelProps } from './config';
+declare var __VLS_4: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_4) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<CascaderPanelProps, {
+    menuList: import("vue").Ref<CascaderMenuInstance[], CascaderMenuInstance[]>;
+    menus: import("vue").Ref<{
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        };
+        readonly config: {
+            expandTrigger: import("./types").ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import("./types").LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import("./types").isDisabled;
+            leaf: string | import("./types").isLeaf;
+            hoverThreshold: number;
+            checkOnClickNode: boolean;
+            checkOnClickLeaf: boolean;
+            showPrefix: boolean;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (checked: boolean) => void;
+        emit: () => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[][], Node[][] | {
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        };
+        readonly config: {
+            expandTrigger: import("./types").ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import("./types").LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import("./types").isDisabled;
+            leaf: string | import("./types").isLeaf;
+            hoverThreshold: number;
+            checkOnClickNode: boolean;
+            checkOnClickLeaf: boolean;
+            showPrefix: boolean;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (checked: boolean) => void;
+        emit: () => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[][]>;
+    checkedNodes: import("vue").Ref<{
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        };
+        readonly config: {
+            expandTrigger: import("./types").ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import("./types").LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import("./types").isDisabled;
+            leaf: string | import("./types").isLeaf;
+            hoverThreshold: number;
+            checkOnClickNode: boolean;
+            checkOnClickLeaf: boolean;
+            showPrefix: boolean;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (checked: boolean) => void;
+        emit: () => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[], Node[] | {
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        };
+        readonly config: {
+            expandTrigger: import("./types").ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import("./types").LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import("./types").isDisabled;
+            leaf: string | import("./types").isLeaf;
+            hoverThreshold: number;
+            checkOnClickNode: boolean;
+            checkOnClickLeaf: boolean;
+            showPrefix: boolean;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (checked: boolean) => void;
+        emit: () => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[]>;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    handleCheckChange: (node: CascaderNode, checked: boolean, emitClose?: boolean) => void;
+    getFlattedNodes: (leafOnly: boolean) => Node[];
+    /**
+     * @description get an array of currently selected node,(leafOnly) whether only return the leaf checked nodes, default is `false`
+     */
+    getCheckedNodes: (leafOnly: boolean) => Node[];
+    /**
+     * @description clear checked nodes
+     */
+    clearCheckedNodes: () => void;
+    calculateCheckedValue: () => void;
+    scrollToExpandingNode: () => void;
+    loadLazyRootNodes: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: CascaderValue | null | undefined) => void;
+    change: (value: CascaderValue | null | undefined) => void;
+    close: () => void;
+    "expand-change": (value: import("./types").CascaderNodePathValue) => void;
+}, string, import("vue").PublicProps, Readonly<CascaderPanelProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: CascaderValue | null | undefined) => any) | undefined;
+    onChange?: ((value: CascaderValue | null | undefined) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    "onExpand-change"?: ((value: import("./types").CascaderNodePathValue) => any) | undefined;
+}>, {
+    props: import("./types").CascaderProps;
+    height: number;
+    border: boolean;
+    options: CascaderOption[];
+    itemSize: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};