ep-craft 0.1.7 → 0.1.9

package/dist/node_modules/element-plus/es/components/tree-select/src/tree-select.vue_vue_type_script_lang.js

@@ -0,0 +1,99 @@
+import { selectProps as g } from "../../select/src/select.js";
+import { ElSelect as k } from "../../select/index.js";
+import { treeProps as _ } from "../../tree/src/tree.js";
+import { ElTree as K } from "../../tree/index.js";
+import { useSelect as N } from "./select.js";
+import { useTree as A } from "./tree.js";
+import P from "./cache-options.js";
+import { defineComponent as b, ref as f, computed as E, reactive as s, onMounted as S, h as a } from "vue";
+import i from "../../../../../lodash-es/pick.js";
+var M = b({
+  name: "ElTreeSelect",
+  inheritAttrs: !1,
+  props: {
+    ...g,
+    ..._,
+    /**
+    * @description The cached data of the lazy node, the structure is the same as the data, used to get the label of the unloaded data
+    */
+    cacheData: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(r, m) {
+    const { slots: c, expose: p, emit: l, attrs: n } = m, h = {
+      ...n,
+      onChange: void 0
+    }, e = f(), t = f(), d = E(() => r.nodeKey || r.valueKey || "value"), v = N(r, {
+      attrs: n,
+      emit: l
+    }, {
+      select: e,
+      tree: t,
+      key: d
+    }), { cacheOptions: C, ...y } = A(r, {
+      attrs: h,
+      slots: c,
+      emit: l
+    }, {
+      select: e,
+      tree: t,
+      key: d
+    }), u = s({});
+    return p(u), S(() => {
+      Object.assign(u, {
+        ...i(t.value, [
+          "filter",
+          "updateKeyChildren",
+          "getCheckedNodes",
+          "setCheckedNodes",
+          "getCheckedKeys",
+          "setCheckedKeys",
+          "setChecked",
+          "getHalfCheckedNodes",
+          "getHalfCheckedKeys",
+          "getCurrentKey",
+          "getCurrentNode",
+          "setCurrentKey",
+          "setCurrentNode",
+          "getNode",
+          "remove",
+          "append",
+          "insertBefore",
+          "insertAfter"
+        ]),
+        ...i(e.value, [
+          "focus",
+          "blur",
+          "selectedLabel"
+        ]),
+        treeRef: t.value,
+        selectRef: e.value
+      });
+    }), () => a(
+      k,
+      /**
+      * 1. The `props` is processed into `Refs`, but `v-bind` and
+      * render function props cannot read `Refs`, so use `reactive`
+      * unwrap the `Refs` and keep reactive.
+      * 2. The keyword `ref` requires `Ref`, but `reactive` broke it,
+      * so use function.
+      */
+      s({
+        ...v,
+        ref: (o) => e.value = o
+      }),
+      {
+        ...c,
+        default: () => [a(P, { data: C.value }), a(K, s({
+          ...y,
+          ref: (o) => t.value = o
+        }))]
+      }
+    );
+  }
+});
+export {
+  M as default
+};

package/dist/node_modules/element-plus/es/components/tree-select/src/tree.js

@@ -0,0 +1,129 @@
+import { UPDATE_MODEL_EVENT as D, CHANGE_EVENT as H } from "../../../constants/event.js";
+import { isEmpty as P } from "../../../utils/types.js";
+import { escapeStringRegexp as R } from "../../../utils/strings.js";
+import { ElTree as _ } from "../../tree/index.js";
+import z from "./tree-select-option.js";
+import { toValidArray as r, treeFind as K, isValidValue as L, treeEach as N, isValidArray as F } from "./utils.js";
+import { watch as I, nextTick as b, computed as C, toRefs as j } from "vue";
+import M from "../../../../../lodash-es/isEqual.js";
+import q from "../../../../../lodash-es/pick.js";
+import B from "../../../../../lodash-es/isNil.js";
+import { isFunction as G } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+const ce = (e, { attrs: u, slots: x, emit: E }, { select: v, tree: t, key: V }) => {
+  I([() => e.modelValue, t], () => {
+    e.showCheckbox && b(() => {
+      const l = t.value;
+      l && !M(l.getCheckedKeys(), r(e.modelValue)) && l.setCheckedKeys(r(e.modelValue));
+    });
+  }, {
+    immediate: !0,
+    deep: !0
+  });
+  const w = C(() => ({
+    value: V.value,
+    label: "label",
+    children: "children",
+    disabled: "disabled",
+    isLeaf: "isLeaf",
+    ...e.props
+  })), n = (l, c) => {
+    var o;
+    const d = w.value[l];
+    return G(d) ? d(c, (o = t.value) == null ? void 0 : o.getNode(n("value", c))) : c[d];
+  }, g = r(e.modelValue).map((l) => K(e.data || [], (c) => n("value", c) === l, (c) => n("children", c), (c, d, o, a) => a && n("value", a))).filter((l) => L(l)), S = C(() => {
+    if (!e.renderAfterExpand && !e.lazy) return [];
+    const l = [];
+    return N(e.data.concat(e.cacheData), (c) => {
+      const d = n("value", c);
+      l.push({
+        value: d,
+        currentLabel: n("label", c),
+        isDisabled: n("disabled", c)
+      });
+    }, (c) => n("children", c)), l;
+  }), O = () => {
+    var l;
+    return (l = t.value) == null ? void 0 : l.getCheckedKeys().filter((c) => {
+      var o;
+      const d = (o = t.value) == null ? void 0 : o.getNode(c);
+      return !B(d) && P(d.childNodes);
+    });
+  }, T = (l) => {
+    M(e.modelValue, l) || E(H, l);
+  };
+  function m(l) {
+    E(D, l), T(l);
+  }
+  return {
+    ...q(j(e), Object.keys(_.props)),
+    ...u,
+    nodeKey: V,
+    expandOnClickNode: C(() => !e.checkStrictly && e.expandOnClickNode),
+    defaultExpandedKeys: C(() => e.defaultExpandedKeys ? e.defaultExpandedKeys.concat(g) : g),
+    renderContent: (l, { node: c, data: d, store: o }) => l(z, {
+      value: n("value", d),
+      label: n("label", d),
+      disabled: n("disabled", d),
+      visible: c.visible
+    }, e.renderContent ? () => e.renderContent(l, {
+      node: c,
+      data: d,
+      store: o
+    }) : x.default ? () => x.default({
+      node: c,
+      data: d,
+      store: o
+    }) : void 0),
+    filterNodeMethod: (l, c, d) => e.filterNodeMethod ? e.filterNodeMethod(l, c, d) : l ? new RegExp(R(l), "i").test(n("label", c) || "") : !0,
+    onNodeClick: (l, c, d) => {
+      var o, a, f;
+      if ((o = u.onNodeClick) == null || o.call(u, l, c, d), !(e.showCheckbox && e.checkOnClickNode))
+        if (!e.showCheckbox && (e.checkStrictly || c.isLeaf)) {
+          if (!n("disabled", l)) {
+            const s = (a = v.value) == null ? void 0 : a.states.options.get(n("value", l));
+            (f = v.value) == null || f.handleOptionSelect(s);
+          }
+        } else e.expandOnClickNode && d.proxy.handleExpandIconClick();
+    },
+    onCheck: (l, c) => {
+      var y;
+      if (!e.showCheckbox) return;
+      const d = n("value", l), o = {};
+      N([t.value.store.root], (i) => o[i.key] = i, (i) => i.childNodes);
+      const a = c.checkedKeys, f = e.multiple ? r(e.modelValue).filter((i) => !(i in o) && !a.includes(i)) : [], s = f.concat(a);
+      if (e.checkStrictly) m(e.multiple ? s : s.includes(d) ? d : void 0);
+      else if (e.multiple) {
+        const i = O();
+        m(f.concat(i));
+      } else {
+        const i = K([l], (h) => !F(n("children", h)) && !n("disabled", h), (h) => n("children", h)), k = i ? n("value", i) : void 0, A = L(e.modelValue) && !!K([l], (h) => n("value", h) === e.modelValue, (h) => n("children", h));
+        m(k === e.modelValue || A ? void 0 : k);
+      }
+      b(() => {
+        var k;
+        const i = r(e.modelValue);
+        t.value.setCheckedKeys(i), (k = u.onCheck) == null || k.call(u, l, {
+          checkedKeys: t.value.getCheckedKeys(),
+          checkedNodes: t.value.getCheckedNodes(),
+          halfCheckedKeys: t.value.getHalfCheckedKeys(),
+          halfCheckedNodes: t.value.getHalfCheckedNodes()
+        });
+      }), (y = v.value) == null || y.focus();
+    },
+    onNodeExpand: (l, c, d) => {
+      var o;
+      (o = u.onNodeExpand) == null || o.call(u, l, c, d), b(() => {
+        if (!e.checkStrictly && e.lazy && e.multiple && c.checked) {
+          const a = {}, f = t.value.getCheckedKeys();
+          N([t.value.store.root], (i) => a[i.key] = i, (i) => i.childNodes);
+          const s = r(e.modelValue).filter((i) => !(i in a) && !f.includes(i)), y = O();
+          m(s.concat(y));
+        }
+      });
+    },
+    cacheOptions: S
+  };
+};
+export {
+  ce as useTree
+};

package/dist/node_modules/element-plus/es/components/tree-select/src/utils.js

@@ -0,0 +1,38 @@
+import { isArray as d } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+function V(n) {
+  return n || n === 0;
+}
+function h(n) {
+  return d(n) && n.length;
+}
+function m(n) {
+  return d(n) ? n : V(n) ? [n] : [];
+}
+function e(n, f, t, u, r) {
+  for (let i = 0; i < n.length; i++) {
+    const o = n[i];
+    if (f(o, i, n, r)) return u ? u(o, i, n, r) : o;
+    {
+      const c = t(o);
+      if (h(c)) {
+        const s = e(c, f, t, u, o);
+        if (s) return s;
+      }
+    }
+  }
+}
+function y(n, f, t, u) {
+  for (let r = 0; r < n.length; r++) {
+    const i = n[r];
+    f(i, r, n, u);
+    const o = t(i);
+    h(o) && y(o, f, t, i);
+  }
+}
+export {
+  h as isValidArray,
+  V as isValidValue,
+  m as toValidArray,
+  y as treeEach,
+  e as treeFind
+};

package/dist/node_modules/element-plus/es/components/tree-v2/index.js

@@ -0,0 +1,7 @@
+import { withInstall as t } from "../../utils/vue/install.js";
+import e from "./src/tree.js";
+const l = t(e);
+export {
+  l as ElTreeV2,
+  l as default
+};

package/dist/node_modules/element-plus/es/components/tree-v2/src/composables/useCheck.js

@@ -0,0 +1,130 @@
+import { NODE_CHECK as G, NODE_CHECK_CHANGE as O } from "../virtual-tree.js";
+import { ref as x, getCurrentInstance as j, watch as q, nextTick as S } from "vue";
+function F(n, t) {
+  const k = x(/* @__PURE__ */ new Set()), y = x(/* @__PURE__ */ new Set()), { emit: N } = j();
+  q([() => t.value, () => n.defaultCheckedKeys], () => S(() => {
+    m(n.defaultCheckedKeys);
+  }), { immediate: !0 });
+  const v = (e = !1) => {
+    if (!t.value || !n.showCheckbox || n.checkStrictly && !e) return;
+    const { levelTreeNodeMap: s, maxLevel: a } = t.value, c = k.value, l = /* @__PURE__ */ new Set();
+    for (let h = a; h >= 1; --h) {
+      const o = s.get(h);
+      o && o.forEach((f) => {
+        const d = f.children;
+        let C = !f.isLeaf || f.disabled || c.has(f.key);
+        if (d) {
+          let u = !0, i = !1;
+          for (const b of d) {
+            const w = b.key;
+            if (b.isEffectivelyChecked || (C = !1), c.has(w)) i = !0;
+            else if (l.has(w)) {
+              u = !1, i = !0;
+              break;
+            } else u = !1;
+          }
+          u ? c.add(f.key) : i ? (l.add(f.key), c.delete(f.key)) : (c.delete(f.key), l.delete(f.key));
+        }
+        f.isEffectivelyChecked = C;
+      });
+    }
+    y.value = l;
+  }, E = (e) => k.value.has(e.key), H = (e) => y.value.has(e.key), r = (e, s, a = !0, c = !0, l = !1) => {
+    const h = k.value, o = e.children;
+    (!n.checkStrictly || l) && a && (o != null && o.length) && (s = o.some((d) => !d.isEffectivelyChecked));
+    const f = (d, C) => {
+      h[C ? "add" : "delete"](d.key);
+      const u = d.children;
+      (!n.checkStrictly || l) && u && u.forEach((i) => {
+        (!i.disabled || i.children) && f(i, C);
+      });
+    };
+    f(e, s), c && v(), a && M(e, s);
+  }, M = (e, s) => {
+    const { checkedNodes: a, checkedKeys: c } = K(), { halfCheckedNodes: l, halfCheckedKeys: h } = g();
+    N(G, e.data, {
+      checkedKeys: c,
+      checkedNodes: a,
+      halfCheckedKeys: h,
+      halfCheckedNodes: l
+    }), N(O, e.data, s);
+  };
+  function _(e = !1) {
+    return K(e).checkedKeys;
+  }
+  function L(e = !1) {
+    return K(e).checkedNodes;
+  }
+  function D() {
+    return g().halfCheckedKeys;
+  }
+  function I() {
+    return g().halfCheckedNodes;
+  }
+  function K(e = !1) {
+    const s = [], a = [];
+    if (t != null && t.value && n.showCheckbox) {
+      const { treeNodeMap: c } = t.value;
+      k.value.forEach((l) => {
+        const h = c.get(l);
+        h && (!e || e && h.isLeaf) && (a.push(l), s.push(h.data));
+      });
+    }
+    return {
+      checkedKeys: a,
+      checkedNodes: s
+    };
+  }
+  function g() {
+    const e = [], s = [];
+    if (t != null && t.value && n.showCheckbox) {
+      const { treeNodeMap: a } = t.value;
+      y.value.forEach((c) => {
+        const l = a.get(c);
+        l && (s.push(c), e.push(l.data));
+      });
+    }
+    return {
+      halfCheckedNodes: e,
+      halfCheckedKeys: s
+    };
+  }
+  function T(e) {
+    k.value.clear(), y.value.clear(), S(() => {
+      m(e);
+    });
+  }
+  function A(e, s, a) {
+    if (t != null && t.value && n.showCheckbox) {
+      const c = t.value.treeNodeMap.get(e);
+      c && r(c, s, !1, void 0, a);
+    }
+  }
+  function m(e) {
+    if (t != null && t.value) {
+      const { treeNodeMap: s } = t.value;
+      if (n.showCheckbox && s && (e == null ? void 0 : e.length) > 0) {
+        for (const a of e) {
+          const c = s.get(a);
+          c && !E(c) && r(c, !0, !1, !1);
+        }
+        v();
+      }
+    }
+  }
+  return {
+    updateCheckedKeys: v,
+    toggleCheckbox: r,
+    isChecked: E,
+    isIndeterminate: H,
+    getCheckedKeys: _,
+    getCheckedNodes: L,
+    getHalfCheckedKeys: D,
+    getHalfCheckedNodes: I,
+    setChecked: A,
+    setCheckedKeys: T
+  };
+}
+export {
+  F as useCheck
+};

package/dist/node_modules/element-plus/es/components/tree-v2/src/composables/useFilter.js

@@ -0,0 +1,44 @@
+import { isFunction as m } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { ref as y, computed as F } from "vue";
+function N(f, p) {
+  const o = y(/* @__PURE__ */ new Set([])), a = y(/* @__PURE__ */ new Set([])), k = F(() => m(f.filterMethod));
+  function x(r) {
+    var h;
+    if (!k.value) return;
+    const d = /* @__PURE__ */ new Set(), l = a.value, n = o.value, s = [], S = ((h = p.value) == null ? void 0 : h.treeNodes) || [], c = f.filterMethod;
+    n.clear();
+    function u(E) {
+      E.forEach((e) => {
+        s.push(e), c != null && c(r, e.data, e) ? s.forEach((t) => {
+          d.add(t.key), t.expanded = !0;
+        }) : (e.expanded = !1, e.isLeaf && n.add(e.key));
+        const i = e.children;
+        if (i && u(i), !e.isLeaf) {
+          if (!d.has(e.key)) n.add(e.key);
+          else if (i) {
+            let t = !0;
+            for (const K of i) if (!n.has(K.key)) {
+              t = !1;
+              break;
+            }
+            t ? l.add(e.key) : l.delete(e.key);
+          }
+        }
+        s.pop();
+      });
+    }
+    return u(S), d;
+  }
+  function v(r) {
+    return a.value.has(r.key);
+  }
+  return {
+    hiddenExpandIconKeySet: a,
+    hiddenNodeKeySet: o,
+    doFilter: x,
+    isForceHiddenExpandIcon: v
+  };
+}
+export {
+  N as useFilter
+};

package/dist/node_modules/element-plus/es/components/tree-v2/src/composables/useTree.js

@@ -0,0 +1,194 @@
+import { isObject as se } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { NODE_COLLAPSE as fe, NODE_EXPAND as he, NODE_DROP as ve, NODE_CLICK as ye, CURRENT_CHANGE as ke } from "../virtual-tree.js";
+import { useCheck as Ne } from "./useCheck.js";
+import { useFilter as ge } from "./useFilter.js";
+import { ref as E, shallowRef as Ce, computed as h, watch as m } from "vue";
+function me(o, v) {
+  const s = E(/* @__PURE__ */ new Set()), f = E(), r = Ce(), N = E(), { isIndeterminate: H, isChecked: O, toggleCheckbox: C, getCheckedKeys: I, getCheckedNodes: A, getHalfCheckedKeys: F, getHalfCheckedNodes: P, setChecked: j, setCheckedKeys: G } = Ne(o, r), { doFilter: U, hiddenNodeKeySet: X, isForceHiddenExpandIcon: q } = ge(o, r), z = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.value) || "id";
+  }), B = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.children) || "children";
+  }), J = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.disabled) || "disabled";
+  }), Q = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.label) || "label";
+  }), p = h(() => {
+    var i;
+    const e = s.value, t = X.value, n = [], c = ((i = r.value) == null ? void 0 : i.treeNodes) || [], a = [];
+    for (let d = c.length - 1; d >= 0; --d) a.push(c[d]);
+    for (; a.length; ) {
+      const d = a.pop();
+      if (!t.has(d.key) && (n.push(d), d.children && e.has(d.key)))
+        for (let l = d.children.length - 1; l >= 0; --l) a.push(d.children[l]);
+    }
+    return n;
+  }), V = h(() => p.value.length > 0);
+  function W(e) {
+    const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+    let c = 1;
+    function a(d, l = 1, ie = void 0) {
+      var R;
+      const S = [];
+      for (const y of d) {
+        const b = x(y), u = {
+          level: l,
+          key: b,
+          data: y
+        };
+        u.label = $(y), u.parent = ie;
+        const k = w(y);
+        u.disabled = Z(y), u.isLeaf = !k || k.length === 0, u.expanded = s.value.has(b), k && k.length && (u.children = a(k, l + 1, u)), S.push(u), t.set(b, u), n.has(l) || n.set(l, []), (R = n.get(l)) == null || R.push(u);
+      }
+      return l > c && (c = l), S;
+    }
+    const i = a(e);
+    return {
+      treeNodeMap: t,
+      levelTreeNodeMap: n,
+      maxLevel: c,
+      treeNodes: i
+    };
+  }
+  function Y(e) {
+    const t = U(e);
+    t && (s.value = t);
+  }
+  function w(e) {
+    return e[B.value];
+  }
+  function x(e) {
+    return e ? e[z.value] : "";
+  }
+  function Z(e) {
+    return e[J.value];
+  }
+  function $(e) {
+    return e[Q.value];
+  }
+  function D(e) {
+    s.value.has(e.key) ? T(e) : M(e);
+  }
+  function K(e) {
+    const t = /* @__PURE__ */ new Set(), n = r.value.treeNodeMap;
+    s.value.forEach((c) => {
+      const a = n.get(c);
+      a && (a.expanded = !1);
+    }), e.forEach((c) => {
+      let a = n.get(c);
+      for (; a && !t.has(a.key); )
+        t.add(a.key), a.expanded = !0, a = a.parent;
+    }), s.value = t;
+  }
+  function ee(e, t) {
+    ne(e), v(ye, e.data, e, t), o.expandOnClickNode && D(e), o.showCheckbox && (o.checkOnClickNode || e.isLeaf && o.checkOnClickLeaf) && !e.disabled && C(e, !O(e), !0);
+  }
+  function te(e, t) {
+    v(ve, e.data, e, t);
+  }
+  function ne(e) {
+    L(e) || (f.value = e.key, v(ke, e.data, e));
+  }
+  function ae(e, t) {
+    C(e, t);
+  }
+  function M(e) {
+    const t = s.value;
+    if (r.value && o.accordion) {
+      const { treeNodeMap: c } = r.value;
+      t.forEach((a) => {
+        const i = c.get(a);
+        e && e.level === (i == null ? void 0 : i.level) && (t.delete(a), i.expanded = !1);
+      });
+    }
+    t.add(e.key);
+    const n = g(e.key);
+    n && (n.expanded = !0, v(he, n.data, n));
+  }
+  function T(e) {
+    s.value.delete(e.key);
+    const t = g(e.key);
+    t && (t.expanded = !1, v(fe, t.data, t));
+  }
+  function oe(e) {
+    return !!e.disabled;
+  }
+  function L(e) {
+    const t = f.value;
+    return t !== void 0 && t === e.key;
+  }
+  function ce() {
+    var e, t;
+    if (f.value !== void 0)
+      return (t = (e = r.value) == null ? void 0 : e.treeNodeMap.get(f.value)) == null ? void 0 : t.data;
+  }
+  function de() {
+    return f.value;
+  }
+  function le(e) {
+    f.value = e;
+  }
+  function _(e) {
+    r.value = W(e);
+  }
+  function g(e) {
+    var n;
+    const t = se(e) ? x(e) : e;
+    return (n = r.value) == null ? void 0 : n.treeNodeMap.get(t);
+  }
+  function re(e, t = "auto") {
+    const n = g(e);
+    n && N.value && N.value.scrollToItem(p.value.indexOf(n), t);
+  }
+  function ue(e) {
+    var t;
+    (t = N.value) == null || t.scrollTo(e);
+  }
+  return m(() => o.currentNodeKey, (e) => {
+    f.value = e;
+  }, { immediate: !0 }), m(() => o.defaultExpandedKeys, (e) => {
+    K(e || []);
+  }), m(() => o.data, (e) => {
+    _(e), K(o.defaultExpandedKeys || []);
+  }, { immediate: !0 }), {
+    tree: r,
+    flattenTree: p,
+    isNotEmpty: V,
+    listRef: N,
+    getKey: x,
+    getChildren: w,
+    toggleExpand: D,
+    toggleCheckbox: C,
+    isChecked: O,
+    isIndeterminate: H,
+    isDisabled: oe,
+    isCurrent: L,
+    isForceHiddenExpandIcon: q,
+    handleNodeClick: ee,
+    handleNodeDrop: te,
+    handleNodeCheck: ae,
+    getCurrentNode: ce,
+    getCurrentKey: de,
+    setCurrentKey: le,
+    getCheckedKeys: I,
+    getCheckedNodes: A,
+    getHalfCheckedKeys: F,
+    getHalfCheckedNodes: P,
+    setChecked: j,
+    setCheckedKeys: G,
+    filter: Y,
+    setData: _,
+    getNode: g,
+    expandNode: M,
+    collapseNode: T,
+    setExpandedKeys: K,
+    scrollToNode: re,
+    scrollTo: ue
+  };
+}
+export {
+  me as useTree
+};

package/dist/node_modules/element-plus/es/components/tree-v2/src/tree-node-content.js

@@ -0,0 +1,25 @@
+import { useNamespace as s } from "../../../hooks/use-namespace/index.js";
+import { ElText as a } from "../../text/index.js";
+import { treeNodeContentProps as l, ROOT_TREE_INJECTION_KEY as p } from "./virtual-tree.js";
+import { defineComponent as c, inject as d, h as m } from "vue";
+var _ = c({
+  name: "ElTreeNodeContent",
+  props: l,
+  setup(o) {
+    const e = d(p), n = s("tree");
+    return () => {
+      const t = o.node, { data: r } = t;
+      return e != null && e.ctx.slots.default ? e.ctx.slots.default({
+        node: t,
+        data: r
+      }) : m(a, {
+        tag: "span",
+        truncated: !0,
+        class: n.be("node", "label")
+      }, () => [t == null ? void 0 : t.label]);
+    };
+  }
+});
+export {
+  _ as default
+};

package/dist/node_modules/element-plus/es/components/tree-v2/src/tree-node.js

@@ -0,0 +1,5 @@
+import e from "./tree-node.vue_vue_type_script_setup_true_lang.js";
+var _ = e;
+export {
+  _ as default
+};