ep-craft 0.1.33 → 0.1.35

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

@@ -0,0 +1,266 @@
+import { defineComponent as ce, useSlots as ne, ref as h, computed as S, provide as ie, reactive as U, watch as I, onBeforeUpdate as ue, onMounted as de, openBlock as L, createElementBlock as j, normalizeClass as fe, unref as J, Fragment as pe, renderList as ve, createBlock as me, withCtx as he, renderSlot as ge, nextTick as Ne } from "vue";
+import { isEqual as $, flattenDeep as Ee, cloneDeep as ye } from "lodash-unified";
+import { unique as Y, castArray as Z } from "../../utils/arrays.js";
+import { isClient as Ce } from "@vueuse/core";
+import { isEmpty as Q } from "../../utils/types.js";
+import "@vue/shared";
+import { focusNode as z, getSibling as ke } from "../../utils/dom/aria.js";
+import { getEventCode as Se } from "../../utils/dom/event.js";
+import { scrollIntoView as _e } from "../../utils/dom/scroll.js";
+import "@element-plus/icons-vue";
+import { EVENT_CODE as g } from "../../constants/aria.js";
+import { UPDATE_MODEL_EVENT as xe, CHANGE_EVENT as be } from "../../constants/event.js";
+import { useNamespace as Ie } from "../../hooks/use-namespace/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 we from "./EpCascaderMenu.vue.js";
+import W from "./store.js";
+import Ae from "./node.js";
+import { cascaderPanelEmits as De, CASCADER_PANEL_HEIGHT as Ve, CASCADER_PANEL_ITEM_SIZE as Le, useCascaderConfig as $e } from "./config.js";
+import { sortByOriginalOrder as ze, checkNode as Be, getMenuIndex as B } from "./utils.js";
+import { CASCADER_PANEL_INJECTION_KEY as Te } from "./types.js";
+const it = /* @__PURE__ */ ce({
+  name: "EpCascaderPanel",
+  __name: "EpCascaderPanel",
+  props: {
+    border: { type: Boolean, default: !0 },
+    renderLabel: {},
+    modelValue: {},
+    options: { default: () => [] },
+    props: { default: () => ({}) },
+    virtualScroll: { type: Boolean },
+    itemSize: { default: Le },
+    height: { default: Ve }
+  },
+  emits: De,
+  setup(T, { expose: X, emit: ee }) {
+    const u = T, k = ee;
+    let _ = !1;
+    const d = Ie("cascader"), f = $e(u), te = ne();
+    let r;
+    const N = h(!0), O = h(!1), m = h([]), x = h(), p = h([]), E = h(), v = h([]), oe = S(() => f.value.expandTrigger === "hover"), le = S(() => u.renderLabel || te.default), b = S(() => u.virtualScroll), P = S(() => u.itemSize), q = S(() => u.height), w = () => {
+      const { options: e } = u, t = f.value;
+      _ = !1, r = new W(e, t), p.value = [r.getNodes()], t.lazy && Q(u.options) ? (N.value = !1, A(void 0, (l) => {
+        l && (r = new W(l, t), p.value = [r.getNodes()]), N.value = !0, y(!1, !0);
+      })) : y(!1, !0);
+    }, A = (e, t) => {
+      const l = f.value;
+      e = e || new Ae({}, l, void 0, !0), e.loading = !0;
+      const a = (s) => {
+        const c = e, n = c.root ? null : c;
+        c.loading = !1, c.loaded = !0, c.childrenData = c.childrenData || [], s && (r == null || r.appendNodes(s, n)), s && (t == null || t(s)), e.level === 0 && (O.value = !0);
+      }, o = () => {
+        e.loading = !1, e.loaded = !1, e.level === 0 && (N.value = !0);
+      };
+      l.lazyLoad(e, a, o);
+    }, D = (e, t) => {
+      var s;
+      const { level: l } = e, a = p.value.slice(0, l);
+      let o;
+      e.isLeaf ? o = e.pathNodes[l - 2] : (o = e, a.push(e.children)), ((s = E.value) == null ? void 0 : s.uid) !== (o == null ? void 0 : o.uid) && (E.value = e, p.value = a, !t && k("expand-change", (e == null ? void 0 : e.pathValues) || []));
+    }, M = (e, t, l = !0) => {
+      const { checkStrictly: a, multiple: o } = f.value, s = v.value[0];
+      _ = !0, !o && (s == null || s.doCheck(!1)), e.doCheck(t), V(), l && !o && !a && k("close"), !l && !o && F(e);
+    }, F = (e) => {
+      e && (e = e.parent, F(e), e && D(e));
+    }, H = (e) => r == null ? void 0 : r.getFlattedNodes(e), R = (e) => {
+      var t;
+      return (t = H(e)) == null ? void 0 : t.filter(({ checked: l }) => l !== !1);
+    }, ae = () => {
+      v.value.forEach((e) => e.doCheck(!1)), V(), p.value = p.value.slice(0, 1), E.value = void 0, k("expand-change", []);
+    }, V = () => {
+      const { checkStrictly: e, multiple: t } = f.value, l = v.value, a = R(!e), o = ze(l, a), s = o.map((c) => c.valueByOption);
+      v.value = o, x.value = t ? s : s[0] ?? null;
+    }, y = (e = !1, t = !1) => {
+      const { modelValue: l } = u, { lazy: a, multiple: o, checkStrictly: s } = f.value, c = !s;
+      if (!(!N.value || _ || !t && $(l, x.value)))
+        if (a && !e) {
+          const C = Y(
+            Ee(Z(l))
+          ).map((i) => r == null ? void 0 : r.getNodeByValue(i)).filter((i) => !!i && !i.loaded && !i.loading);
+          C.length ? C.forEach((i) => {
+            A(i, () => y(!1, t));
+          }) : y(!0, t);
+        } else {
+          const n = o ? Z(l) : [l], C = Y(
+            n.map(
+              (i) => r == null ? void 0 : r.getNodeByValue(i, c)
+            )
+          );
+          se(C, t), x.value = ye(l ?? void 0);
+        }
+    }, se = (e, t = !0) => {
+      const { checkStrictly: l } = f.value, a = v.value, o = e.filter(
+        (n) => !!n && (l || n.isLeaf)
+      ), s = r == null ? void 0 : r.getSameNode(E.value), c = t && s || o[0];
+      c ? c.pathNodes.forEach((n) => D(n, !0)) : E.value = void 0, a.forEach((n) => n.doCheck(!1)), U(o).forEach((n) => n.doCheck(!0)), v.value = o, Ne(K);
+    }, K = () => {
+      Ce && m.value.forEach((e) => {
+        var l, a;
+        const t = e == null ? void 0 : e.$el;
+        if (t)
+          if (b.value) {
+            const o = (l = e == null ? void 0 : e.getActiveNodeIndex) == null ? void 0 : l.call(e);
+            o !== void 0 && o >= 0 && ((a = e == null ? void 0 : e.scrollToItem) == null || a.call(e, o));
+          } else {
+            const o = t.querySelector(
+              `.${d.namespace.value}-scrollbar__wrap`
+            );
+            let s = t.querySelector(
+              `.${d.b("node")}.in-active-path`
+            );
+            if (!s) {
+              const c = t.querySelectorAll(
+                `.${d.b("node")}.${d.is("active")}`
+              );
+              s = c[c.length - 1];
+            }
+            _e(o, s);
+          }
+      });
+    }, G = (e) => {
+      const t = e.target, l = Se(e);
+      switch (l) {
+        case g.up:
+        case g.down: {
+          e.preventDefault();
+          const a = l === g.up ? -1 : 1;
+          if (b.value) {
+            const o = B(t), s = m.value[o];
+            if (s) {
+              const c = s.getNodeIndexById(t.id);
+              if (c >= 0) {
+                const n = p.value[o] ?? [], C = n.length;
+                let i = c + a;
+                for (; i >= 0 && i < C; ) {
+                  if (!n[i].isDisabled) {
+                    s.focusNodeAt(i);
+                    return;
+                  }
+                  i += a;
+                }
+              }
+            }
+          }
+          z(
+            ke(
+              t,
+              a,
+              `.${d.b("node")}[tabindex="-1"]`
+            )
+          );
+          break;
+        }
+        case g.left: {
+          e.preventDefault();
+          const a = m.value[B(t) - 1], o = a == null ? void 0 : a.$el.querySelector(
+            `.${d.b("node")}[aria-expanded="true"]`
+          );
+          z(o);
+          break;
+        }
+        case g.right: {
+          e.preventDefault();
+          const a = m.value[B(t) + 1], o = a == null ? void 0 : a.$el.querySelector(
+            `.${d.b("node")}[tabindex="-1"]`
+          );
+          z(o);
+          break;
+        }
+        case g.enter:
+        case g.numpadEnter:
+          Be(t);
+          break;
+      }
+    };
+    ie(
+      Te,
+      U({
+        config: f,
+        expandingNode: E,
+        checkedNodes: v,
+        isHoverMenu: oe,
+        initialLoaded: N,
+        renderLabelFn: le,
+        virtualScroll: b,
+        itemSize: P,
+        height: q,
+        lazyLoad: A,
+        expandNode: D,
+        handleCheckChange: M
+      })
+    ), I(
+      f,
+      (e, t) => {
+        $(e, t) || w();
+      },
+      {
+        immediate: !0
+      }
+    ), I(() => u.options, w, {
+      deep: !0
+    }), I(
+      () => u.modelValue,
+      () => {
+        _ = !1, y();
+      },
+      {
+        deep: !0
+      }
+    ), I(
+      () => x.value,
+      (e) => {
+        $(e, u.modelValue) || (k(xe, e), k(be, e));
+      }
+    );
+    const re = () => {
+      O.value || !N.value || w();
+    };
+    return ue(() => m.value = []), de(() => !Q(u.modelValue) && y()), X({
+      menuList: m,
+      menus: p,
+      checkedNodes: v,
+      handleKeyDown: G,
+      handleCheckChange: M,
+      getFlattedNodes: H,
+      /**
+       * @description get an array of currently selected node,(leafOnly) whether only return the leaf checked nodes, default is `false`
+       */
+      getCheckedNodes: R,
+      /**
+       * @description clear checked nodes
+       */
+      clearCheckedNodes: ae,
+      calculateCheckedValue: V,
+      scrollToExpandingNode: K,
+      loadLazyRootNodes: re
+    }), (e, t) => (L(), j("div", {
+      class: fe([J(d).b("panel"), J(d).is("bordered", T.border)]),
+      onKeydown: G
+    }, [
+      (L(!0), j(pe, null, ve(p.value, (l, a) => (L(), me(we, {
+        key: a,
+        ref_for: !0,
+        ref: (o) => m.value[a] = o,
+        index: a,
+        nodes: [...l],
+        "virtual-scroll": b.value,
+        "item-size": P.value,
+        height: q.value
+      }, {
+        empty: he(() => [
+          ge(e.$slots, "empty")
+        ]),
+        _: 3
+      }, 8, ["index", "nodes", "virtual-scroll", "item-size", "height"]))), 128))
+    ], 34));
+  }
+});
+export {
+  it as default
+};

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

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

package/dist/components/cascader-panel/config.d.ts

@@ -0,0 +1,102 @@
+import type { PropType } from 'vue';
+import type { CascaderConfig, CascaderNodePathValue, CascaderOption, CascaderProps, CascaderValue, RenderLabel } from './types';
+export interface CascaderCommonProps {
+    /**
+     * @description specify which key of node object is used as the node's value
+     */
+    modelValue?: CascaderValue | null;
+    /**
+     * @description data of the options, the key of `value` and `label` can be customize by `CascaderProps`.
+     */
+    options?: CascaderOption[];
+    /**
+     * @description configuration options, see the following `CascaderProps` table.
+     */
+    props?: CascaderProps;
+    /**
+     * @description whether to enable virtual scrolling
+     */
+    virtualScroll?: boolean;
+    /**
+     * @description node height for virtual scrolling
+     */
+    itemSize?: number;
+    /**
+     * @description menu height for virtual scrolling
+     */
+    height?: number;
+}
+/**
+ * @description node height for virtual scrolling
+ */
+export declare const CASCADER_PANEL_ITEM_SIZE = 34;
+/**
+ * @description menu height for virtual scrolling
+ */
+export declare const CASCADER_PANEL_HEIGHT = 204;
+export declare const CommonProps: {
+    readonly modelValue: {
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | number | Record<string, any> | CascaderNodePathValue | (import("./types").CascaderNodeValue | CascaderNodePathValue)[]) | (() => CascaderValue | null) | (((new (...args: any[]) => string | number | Record<string, any> | CascaderNodePathValue | (import("./types").CascaderNodeValue | CascaderNodePathValue)[]) | (() => CascaderValue | null)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly options: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[]) | (((new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[])) | null)[], unknown, unknown, () => CascaderOption[], boolean>;
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => CascaderProps) | (() => CascaderProps) | (((new (...args: any[]) => CascaderProps) | (() => CascaderProps)) | null)[], unknown, unknown, () => CascaderProps, boolean>;
+    readonly virtualScroll: BooleanConstructor;
+    readonly itemSize: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 34, boolean>;
+    readonly height: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 204, boolean>;
+};
+export interface CascaderPanelProps extends CascaderCommonProps {
+    border?: boolean;
+    renderLabel?: RenderLabel;
+}
+export declare const DefaultProps: CascaderConfig;
+/**
+ * @deprecated Removed after 3.0.0, Use `CascaderPanelProps` instead.
+ */
+export declare const cascaderPanelProps: {
+    border: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    renderLabel: {
+        readonly type: PropType<RenderLabel>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    modelValue: {
+        readonly type: PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | number | Record<string, any> | CascaderNodePathValue | (import("./types").CascaderNodeValue | CascaderNodePathValue)[]) | (() => CascaderValue | null) | (((new (...args: any[]) => string | number | Record<string, any> | CascaderNodePathValue | (import("./types").CascaderNodeValue | CascaderNodePathValue)[]) | (() => CascaderValue | null)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[]) | (((new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[])) | null)[], unknown, unknown, () => CascaderOption[], boolean>;
+    props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => CascaderProps) | (() => CascaderProps) | (((new (...args: any[]) => CascaderProps) | (() => CascaderProps)) | null)[], unknown, unknown, () => CascaderProps, boolean>;
+    virtualScroll: BooleanConstructor;
+    itemSize: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 34, boolean>;
+    height: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 204, boolean>;
+};
+export declare const cascaderPanelEmits: {
+    "update:modelValue": (value: CascaderValue | undefined | null) => boolean;
+    change: (value: CascaderValue | undefined | null) => boolean;
+    close: () => boolean;
+    'expand-change': (value: CascaderNodePathValue) => CascaderNodePathValue;
+};
+export declare const useCascaderConfig: (props: {
+    props: CascaderProps;
+}) => import("vue").ComputedRef<{
+    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;
+}>;

package/dist/components/cascader-panel/config.js

@@ -0,0 +1,136 @@
+import { computed as l } from "vue";
+import { NOOP as a } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { CHANGE_EVENT as c, UPDATE_MODEL_EVENT as i } from "../../constants/event.js";
+import "@element-plus/icons-vue";
+import { buildProps as o, definePropType as r } from "../../utils/vue/props/runtime.js";
+const n = 34, p = 204, s = o({
+  /**
+   * @description specify which key of node object is used as the node's value
+   */
+  modelValue: {
+    type: r([Number, String, Array, Object])
+  },
+  /**
+   * @description data of the options, the key of `value` and `label` can be customize by `CascaderProps`.
+   */
+  options: {
+    type: r(Array),
+    default: () => []
+  },
+  /**
+   * @description configuration options, see the following `CascaderProps` table.
+   */
+  props: {
+    type: r(Object),
+    default: () => ({})
+  },
+  /**
+   * @description whether to enable virtual scrolling
+   */
+  virtualScroll: Boolean,
+  /**
+   * @description node height for virtual scrolling
+   */
+  itemSize: {
+    type: Number,
+    default: n
+  },
+  /**
+   * @description menu height for virtual scrolling
+   */
+  height: {
+    type: Number,
+    default: p
+  }
+}), u = {
+  /**
+   * @description trigger mode of expanding options
+   */
+  expandTrigger: "click",
+  /**
+   * @description whether multiple selection is enabled
+   */
+  multiple: !1,
+  /**
+   * @description whether checked state of a node not affects its parent and child nodes
+   */
+  checkStrictly: !1,
+  // whether all nodes can be selected
+  /**
+   * @description when checked nodes change, whether to emit an array of node's path, if false, only emit the value of node.
+   */
+  emitPath: !0,
+  // whether to emit an array of all levels value in which node is located
+  /**
+   * @description whether to dynamic load child nodes, use with `lazyload` attribute
+   */
+  lazy: !1,
+  /**
+   * @description method for loading child nodes data, only works when `lazy` is true
+   */
+  lazyLoad: a,
+  /**
+   * @description specify which key of node object is used as the node's value
+   */
+  value: "value",
+  /**
+   * @description specify which key of node object is used as the node's label
+   */
+  label: "label",
+  /**
+   * @description specify which key of node object is used as the node's children
+   */
+  children: "children",
+  /**
+   * @description specify which key of node object is used as the node's leaf
+   */
+  leaf: "leaf",
+  /**
+   * @description specify which key of node object is used as the node's disabled
+   */
+  disabled: "disabled",
+  /**
+   * @description hover threshold of expanding options
+   */
+  hoverThreshold: 500,
+  /**
+   * @description whether to check or uncheck node when clicking on the node
+   */
+  checkOnClickNode: !1,
+  /**
+   * @description whether to check or uncheck node when clicking on leaf node (last children).
+   */
+  checkOnClickLeaf: !0,
+  /**
+   * @description whether to show the radio or checkbox prefix
+   */
+  showPrefix: !0
+}, b = o({
+  ...s,
+  border: {
+    type: Boolean,
+    default: !0
+  },
+  renderLabel: {
+    type: Function
+  }
+}), t = (e) => !0, C = {
+  [i]: t,
+  [c]: t,
+  close: () => !0,
+  "expand-change": (e) => e
+}, A = (e) => l(() => ({
+  ...u,
+  ...e.props
+}));
+export {
+  p as CASCADER_PANEL_HEIGHT,
+  n as CASCADER_PANEL_ITEM_SIZE,
+  s as CommonProps,
+  u as DefaultProps,
+  C as cascaderPanelEmits,
+  b as cascaderPanelProps,
+  A as useCascaderConfig
+};

package/dist/components/cascader-panel/index.d.ts

@@ -1,4 +1,19 @@
 import type { Plugin } from 'vue';
-import { ElCascaderPanel } from 'element-plus';
-export declare const EpCascaderPanel: typeof ElCascaderPanel & Plugin;
+import _EpCascaderPanel from './EpCascaderPanel.vue';
+/**
+ * cascader-panel 自持 barrel（vendor-batch-3 产出）。
+ *
+ * 面板本体不读取表单上下文；表单级 disabled / size 由外层 `EpCascader`
+ * 从本地表单中枢取得后经 props 传入，保证与 `EpForm` / `EpFormItem` 对齐。
+ *
+ * `CascaderNode` 以值形式再导出 `node.ts` 的 `Node` 类（上游同形），
+ * 因此与 `types.ts` 中的同名类型别名共用同一个标识符。
+ *
+ * 不导出 `ElCascaderPanel` 别名。
+ */
+export declare const EpCascaderPanel: typeof _EpCascaderPanel & Plugin;
 export default EpCascaderPanel;
+export { default as CascaderNode } from './node';
+export * from './config';
+export * from './instance';
+export * from './types';

package/dist/components/cascader-panel/index.js

@@ -1,6 +1,23 @@
-import { ElCascaderPanel as a } from "element-plus";
-import { withInstall as e } from "../../utils/with-install.js";
-const n = Object.assign({}, a, { name: "EpCascaderPanel" }), c = e(n, "ep-cascader-panel");
+import { withInstall as r } from "../../utils/with-install.js";
+import a from "./EpCascaderPanel.vue.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "vue";
+import { CASCADER_PANEL_HEIGHT as l, CASCADER_PANEL_ITEM_SIZE as C, CommonProps as P, DefaultProps as f, cascaderPanelEmits as _, cascaderPanelProps as d, useCascaderConfig as A } from "./config.js";
+const c = r(
+  a,
+  "ep-cascader-panel"
+);
 export {
-  c as EpCascaderPanel
+  l as CASCADER_PANEL_HEIGHT,
+  C as CASCADER_PANEL_ITEM_SIZE,
+  P as CommonProps,
+  f as DefaultProps,
+  c as EpCascaderPanel,
+  _ as cascaderPanelEmits,
+  d as cascaderPanelProps,
+  c as default,
+  A as useCascaderConfig
 };

package/dist/components/cascader-panel/instance.d.ts

@@ -0,0 +1,4 @@
+import type EpCascaderMenu from './EpCascaderMenu.vue';
+import type EpCascaderPanel from './EpCascaderPanel.vue';
+export type CascaderMenuInstance = InstanceType<typeof EpCascaderMenu> & unknown;
+export type CascaderPanelInstance = InstanceType<typeof EpCascaderPanel> & unknown;

package/dist/components/cascader-panel/node-content.d.ts

@@ -0,0 +1,14 @@
+import type { PropType } from 'vue';
+import type { CascaderNode } from './types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<CascaderNode>;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: PropType<CascaderNode>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/cascader-panel/node-content.js

@@ -0,0 +1,50 @@
+import { defineComponent as c, inject as s, createVNode as d, Comment as a } from "vue";
+import { useNamespace as l } from "../../hooks/use-namespace/index.js";
+import { isArray as u } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@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 { CASCADER_PANEL_INJECTION_KEY as C } from "./types.js";
+function N(t) {
+  return !!(u(t) ? t.every(({
+    type: e
+  }) => e === a) : (t == null ? void 0 : t.type) === a);
+}
+const J = /* @__PURE__ */ c({
+  name: "EpCascaderNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    }
+  },
+  setup(t) {
+    const e = l("cascader-node"), {
+      renderLabelFn: r
+    } = s(C), {
+      node: o
+    } = t, {
+      data: n,
+      label: p
+    } = o, i = () => {
+      const m = r == null ? void 0 : r({
+        node: o,
+        data: n
+      });
+      return N(m) ? p : m ?? p;
+    };
+    return () => d("span", {
+      class: e.e("label")
+    }, [i()]);
+  }
+});
+export {
+  J as default
+};

package/dist/components/cascader-panel/node.d.ts

@@ -0,0 +1,50 @@
+import type { CascaderConfig, CascaderNodePathValue, CascaderNodeValue, CascaderOption } from './types';
+type ChildrenData = CascaderOption[] | undefined;
+declare class Node {
+    readonly data: CascaderOption;
+    readonly config: CascaderConfig;
+    readonly parent?: Node | undefined;
+    readonly root: boolean;
+    readonly uid: number;
+    readonly level: number;
+    readonly value: CascaderNodeValue;
+    readonly label: string;
+    readonly pathNodes: Node[];
+    readonly pathValues: CascaderNodePathValue;
+    readonly pathLabels: string[];
+    childrenData: ChildrenData;
+    children: Node[];
+    text: string;
+    loaded: boolean;
+    /**
+     * Is it checked
+     *
+     * @default false
+     */
+    checked: boolean;
+    /**
+     * Used to indicate the intermediate state of unchecked and fully checked child nodes
+     *
+     * @default false
+     */
+    indeterminate: boolean;
+    /**
+     * Loading Status
+     *
+     * @default false
+     */
+    loading: boolean;
+    constructor(data: CascaderOption, config: CascaderConfig, parent?: Node | undefined, root?: boolean);
+    get isDisabled(): boolean;
+    get isLeaf(): boolean;
+    get valueByOption(): CascaderNodeValue | CascaderNodePathValue;
+    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;
+}
+export default Node;