ep-craft 0.1.13 → 0.1.15

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tree/src/tree-node.vue_vue_type_script_lang.js

@@ -0,0 +1,139 @@
+import { isFunction as b, isString as I } from "../../../../../../../@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { debugWarn as T } from "../../../utils/error.js";
+import { useNamespace as S } from "../../../hooks/use-namespace/index.js";
+import { ElIcon as L } from "../../icon/index.js";
+import { ElCheckbox as R } from "../../checkbox/index.js";
+import { ElCollapseTransition as B } from "../../collapse-transition/index.js";
+import { handleCurrentChange as w, getNodeKey as F } from "./model/util.js";
+import $ from "./model/node.js";
+import { ROOT_TREE_INJECTION_KEY as j, NODE_INSTANCE_INJECTION_KEY as A } from "./tokens.js";
+import H from "./tree-node-content.js";
+import { useNodeExpandEventBroadcast as J } from "./model/useNodeExpandEventBroadcast.js";
+import { dragEventsKey as Y } from "./model/useDragNode.js";
+import { Loading as M, CaretRight as P } from "../../../../../../../@element-plus_icons-vue@2.3.2_vue@3.5.40_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.js";
+import { defineComponent as W, inject as x, ref as r, getCurrentInstance as q, provide as z, watch as l, nextTick as E } from "vue";
+var ue = W({
+  name: "ElTreeNode",
+  components: {
+    ElCollapseTransition: B,
+    ElCheckbox: R,
+    NodeContent: H,
+    ElIcon: L,
+    Loading: M
+  },
+  props: {
+    node: {
+      type: $,
+      default: () => ({})
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    accordion: Boolean,
+    renderContent: Function,
+    renderAfterExpand: Boolean,
+    showCheckbox: Boolean
+  },
+  emits: ["node-expand"],
+  setup(n, v) {
+    const y = S("tree"), { broadcastExpanded: _ } = J(n), t = x(j), i = r(!1), s = r(!1), h = r(), f = r(), C = r(), u = x(Y), c = q();
+    z(A, c), t || T("Tree", "Can not find node's tree."), n.node.expanded && (i.value = !0, s.value = !0);
+    const K = t.props.props.children || "children";
+    l(() => {
+      var d;
+      const e = (d = n.node.data) == null ? void 0 : d[K];
+      return e && [...e];
+    }, () => {
+      n.node.updateChildren();
+    }), l(() => n.node.indeterminate, (e) => {
+      m(n.node.checked, e);
+    }), l(() => n.node.checked, (e) => {
+      m(e, n.node.indeterminate);
+    }), l(() => n.node.childNodes.length, () => n.node.reInitChecked()), l(() => n.node.expanded, (e) => {
+      E(() => i.value = e), e && (s.value = !0);
+    });
+    const g = (e) => t.props.nodeKey ? F(t.props.nodeKey, e.data) : e.id, D = (e) => {
+      const d = n.props.class;
+      if (!d) return {};
+      let o;
+      if (b(d)) {
+        const { data: a } = e;
+        o = d(a, e);
+      } else o = d;
+      return I(o) ? { [o]: !0 } : o;
+    }, m = (e, d) => {
+      (h.value !== e || f.value !== d) && t.ctx.emit("check-change", n.node.data, e, d), h.value = e, f.value = d;
+    }, O = (e) => {
+      w(t.store, t.ctx.emit, () => {
+        var d;
+        if ((d = t == null ? void 0 : t.props) != null && d.nodeKey) {
+          const o = g(n.node);
+          t.store.value.setCurrentNodeKey(o);
+        } else t.store.value.setCurrentNode(n.node);
+      }), t.currentNode.value = n.node, t.props.expandOnClickNode && N(), (t.props.checkOnClickNode || n.node.isLeaf && t.props.checkOnClickLeaf && n.showCheckbox) && !n.node.disabled && k(!n.node.checked), t.ctx.emit("node-click", n.node.data, n.node, c, e);
+    }, p = (e) => {
+      var d;
+      (d = t.instance.vnode.props) != null && d.onNodeContextmenu && (e.stopPropagation(), e.preventDefault()), t.ctx.emit("node-contextmenu", e, n.node.data, n.node, c);
+    }, N = () => {
+      n.node.isLeaf || (i.value ? (t.ctx.emit("node-collapse", n.node.data, n.node, c), n.node.collapse()) : n.node.expand(() => {
+        v.emit("node-expand", n.node.data, n.node, c);
+      }));
+    }, k = (e) => {
+      const d = t == null ? void 0 : t.props.checkStrictly, o = n.node.childNodes;
+      !d && o.length && (e = o.some((a) => !a.isEffectivelyChecked)), n.node.setChecked(e, !d), E(() => {
+        const a = t.store.value;
+        t.ctx.emit("check", n.node.data, {
+          checkedNodes: a.getCheckedNodes(),
+          checkedKeys: a.getCheckedKeys(),
+          halfCheckedNodes: a.getHalfCheckedNodes(),
+          halfCheckedKeys: a.getHalfCheckedKeys()
+        });
+      });
+    };
+    return {
+      ns: y,
+      node$: C,
+      tree: t,
+      expanded: i,
+      childNodeRendered: s,
+      oldChecked: h,
+      oldIndeterminate: f,
+      getNodeKey: g,
+      getNodeClass: D,
+      handleSelectChange: m,
+      handleClick: O,
+      handleContextMenu: p,
+      handleExpandIconClick: N,
+      handleCheckChange: k,
+      handleChildNodeExpand: (e, d, o) => {
+        _(d), t.ctx.emit("node-expand", e, d, o);
+      },
+      handleDragStart: (e) => {
+        t.props.draggable && u.treeNodeDragStart({
+          event: e,
+          treeNode: n
+        });
+      },
+      handleDragOver: (e) => {
+        e.preventDefault(), t.props.draggable && u.treeNodeDragOver({
+          event: e,
+          treeNode: {
+            $el: C.value,
+            node: n.node
+          }
+        });
+      },
+      handleDrop: (e) => {
+        e.preventDefault();
+      },
+      handleDragEnd: (e) => {
+        t.props.draggable && u.treeNodeDragEnd(e);
+      },
+      CaretRight: P
+    };
+  }
+});
+export {
+  ue as default
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tree/src/tree.vue_vue_type_script_lang.js

@@ -0,0 +1,157 @@
+import { useLocale as Y } from "../../../hooks/use-locale/index.js";
+import { useNamespace as j } from "../../../hooks/use-namespace/index.js";
+import { formItemContextKey as F } from "../../form/src/constants.js";
+import { handleCurrentChange as C, getNodeKey as G } from "./model/util.js";
+import Q from "./model/tree-store.js";
+import { ROOT_TREE_INJECTION_KEY as W } from "./tokens.js";
+import { useNodeExpandEventBroadcast as X } from "./model/useNodeExpandEventBroadcast.js";
+import { useDragNodeHandler as Z } from "./model/useDragNode.js";
+import V from "./tree-node.js";
+import { useKeydown as ee } from "./model/useKeydown.js";
+import { treeEmits as te, treeProps as re } from "./tree.js";
+import { defineComponent as ne, ref as l, getCurrentInstance as de, computed as K, watch as s, provide as v } from "vue";
+import oe from "../../../../../../../lodash-es@4.18.1/node_modules/lodash-es/isEqual.js";
+var ve = ne({
+  name: "ElTree",
+  components: { ElTreeNode: V },
+  props: re,
+  emits: te,
+  setup(n, a) {
+    const { t: k } = Y(), g = j("tree"), t = l(new Q({
+      key: n.nodeKey,
+      data: n.data,
+      lazy: n.lazy,
+      props: n.props,
+      load: n.load,
+      currentNodeKey: n.currentNodeKey,
+      checkStrictly: n.checkStrictly,
+      checkDescendants: n.checkDescendants,
+      defaultCheckedKeys: n.defaultCheckedKeys,
+      defaultExpandedKeys: n.defaultExpandedKeys,
+      autoExpandParent: n.autoExpandParent,
+      defaultExpandAll: n.defaultExpandAll,
+      filterNodeMethod: n.filterNodeMethod
+    }));
+    t.value.initialize();
+    const c = l(t.value.root), h = l(null), f = l(null), m = l(null), { broadcastExpanded: y } = X(n), { dragState: E } = Z({
+      props: n,
+      ctx: a,
+      el$: f,
+      dropIndicator$: m,
+      store: t
+    });
+    ee({ el$: f }, t);
+    const i = de(), _ = K(() => {
+      let e = i == null ? void 0 : i.parent;
+      for (; e; ) {
+        if (e.type.name === "ElTreeSelect") return !0;
+        e = e.parent;
+      }
+      return !1;
+    }), p = K(() => {
+      const { childNodes: e } = c.value;
+      return (!e || e.length === 0 || e.every(({ visible: r }) => !r)) && !_.value;
+    });
+    s(() => n.currentNodeKey, (e) => {
+      t.value.setCurrentNodeKey(e ?? null);
+    }), s(() => n.defaultCheckedKeys, (e, r) => {
+      oe(e, r) || t.value.setDefaultCheckedKey(e ?? []);
+    }), s(() => n.defaultExpandedKeys, (e) => {
+      t.value.setDefaultExpandedKeys(e ?? []);
+    }), s(() => n.data, (e) => {
+      t.value.setData(e);
+    }, { deep: !0 }), s(() => n.checkStrictly, (e) => {
+      t.value.checkStrictly = e;
+    });
+    const x = (e) => {
+      if (!n.filterNodeMethod) throw new Error("[Tree] filterNodeMethod is required when filter");
+      t.value.filter(e);
+    }, T = (e) => n.nodeKey ? G(n.nodeKey, e.data) : e.id, d = (e) => {
+      if (!n.nodeKey) throw new Error(`[Tree] nodeKey is required in ${e}`);
+    }, w = (e) => {
+      d("getNodePath");
+      const r = t.value.getNode(e);
+      if (!r) return [];
+      const o = [r.data];
+      let u = r.parent;
+      for (; u && u !== c.value; )
+        o.push(u.data), u = u.parent;
+      return o.reverse();
+    }, S = (e, r) => t.value.getCheckedNodes(e, r), D = (e) => t.value.getCheckedKeys(e), N = () => {
+      const e = t.value.getCurrentNode();
+      return e ? e.data : null;
+    }, H = () => {
+      d("getCurrentKey");
+      const e = N();
+      return e ? e[n.nodeKey] : null;
+    }, I = (e, r) => {
+      d("setCheckedNodes"), t.value.setCheckedNodes(e, r);
+    }, P = (e, r) => {
+      d("setCheckedKeys"), t.value.setCheckedKeys(e, r);
+    }, q = (e, r, o = !1) => {
+      t.value.setChecked(e, r, o);
+    }, A = () => t.value.getHalfCheckedNodes(), M = () => t.value.getHalfCheckedKeys(), $ = (e, r = !0) => {
+      d("setCurrentNode"), C(t, a.emit, () => {
+        y(e), t.value.setUserCurrentNode(e, r);
+      });
+    }, z = (e = null, r = !0) => {
+      d("setCurrentKey"), C(t, a.emit, () => {
+        y(), t.value.setCurrentNodeKey(e, r);
+      });
+    }, B = (e) => t.value.getNode(e), O = (e) => {
+      t.value.remove(e);
+    }, R = (e, r) => {
+      t.value.append(e, r);
+    }, b = (e, r) => {
+      t.value.insertBefore(e, r);
+    }, J = (e, r) => {
+      t.value.insertAfter(e, r);
+    }, L = (e, r, o) => {
+      y(r), a.emit("node-expand", e, r, o);
+    }, U = (e, r) => {
+      d("updateKeyChildren"), t.value.updateChildren(e, r);
+    };
+    return v(W, {
+      ctx: a,
+      props: n,
+      store: t,
+      root: c,
+      currentNode: h,
+      instance: i
+    }), v(F, void 0), {
+      ns: g,
+      store: t,
+      root: c,
+      currentNode: h,
+      dragState: E,
+      el$: f,
+      dropIndicator$: m,
+      isEmpty: p,
+      filter: x,
+      getNodeKey: T,
+      getNodePath: w,
+      getCheckedNodes: S,
+      getCheckedKeys: D,
+      getCurrentNode: N,
+      getCurrentKey: H,
+      setCheckedNodes: I,
+      setCheckedKeys: P,
+      setChecked: q,
+      getHalfCheckedNodes: A,
+      getHalfCheckedKeys: M,
+      setCurrentNode: $,
+      setCurrentKey: z,
+      t: k,
+      getNode: B,
+      remove: O,
+      append: R,
+      insertBefore: b,
+      insertAfter: J,
+      handleNodeExpand: L,
+      updateKeyChildren: U
+    };
+  }
+});
+export {
+  ve as default
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tree-select/src/cache-options.js

@@ -0,0 +1,27 @@
+import { selectKey as c } from "../../select/src/token.js";
+import { defineComponent as r, inject as i, watch as l } from "vue";
+import { isClient as n } from "../../../../../../../@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+var p = r({
+  props: { data: {
+    type: Array,
+    default: () => []
+  } },
+  setup(a) {
+    const e = i(c);
+    return l(() => a.data, () => {
+      var s;
+      a.data.forEach((t) => {
+        e.states.cachedOptions.has(t.value) || e.states.cachedOptions.set(t.value, t);
+      });
+      const o = ((s = e.selectRef) == null ? void 0 : s.querySelectorAll("input")) || [];
+      n && !Array.from(o).includes(document.activeElement) && e.setSelected();
+    }, {
+      flush: "post",
+      immediate: !0
+    }), () => {
+    };
+  }
+});
+export {
+  p as default
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tree-select/src/select.js

@@ -0,0 +1,61 @@
+import { EVENT_CODE as i } from "../../../constants/aria.js";
+import { UPDATE_MODEL_EVENT as N } from "../../../constants/event.js";
+import { getEventCode as y } from "../../../utils/dom/event.js";
+import { useNamespace as M } from "../../../hooks/use-namespace/index.js";
+import { ElSelect as C } from "../../select/index.js";
+import { useEventListener as S } from "../../../../../../../@vueuse_core@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import { watch as T, nextTick as p, onMounted as V, computed as n, toRefs as k } from "vue";
+import x from "../../../../../../../lodash-es@4.18.1/node_modules/lodash-es/pick.js";
+const j = (o, { attrs: u, emit: m }, { select: l, tree: s, key: v }) => {
+  const h = M("tree-select");
+  T(() => o.data, () => {
+    o.filterable && p(() => {
+      var e, t;
+      (t = s.value) == null || t.filter((e = l.value) == null ? void 0 : e.states.inputValue);
+    });
+  }, { flush: "post" });
+  const c = (e) => {
+    var a, r;
+    const t = e.at(-1);
+    if (t.expanded && t.childNodes.at(-1)) c([t.childNodes.at(-1)]);
+    else {
+      (r = (a = s.value.el$) == null ? void 0 : a.querySelector(`[data-key="${e.at(-1).key}"]`)) == null || r.focus({ preventScroll: !0 });
+      return;
+    }
+  };
+  return V(() => {
+    S(() => {
+      var e;
+      return (e = l.value) == null ? void 0 : e.$el;
+    }, "keydown", async (e) => {
+      const t = y(e), { dropdownMenuVisible: a } = l.value;
+      [i.down, i.up].includes(t) && a && (await p(), setTimeout(() => {
+        var r, d, f;
+        if (i.up === t) {
+          const E = s.value.store.root.childNodes;
+          c(E);
+          return;
+        }
+        (f = (d = (r = l.value.optionsArray[l.value.states.hoveringIndex].$el) == null ? void 0 : r.parentNode) == null ? void 0 : d.parentNode) == null || f.focus({ preventScroll: !0 });
+      }));
+    }, { capture: !0 });
+  }), {
+    ...x(k(o), Object.keys(C.props)),
+    ...u,
+    class: n(() => u.class),
+    style: n(() => u.style),
+    "onUpdate:modelValue": (e) => m(N, e),
+    valueKey: v,
+    popperClass: n(() => {
+      const e = [h.e("popper")];
+      return o.popperClass && e.push(o.popperClass), e.join(" ");
+    }),
+    filterMethod: (e = "") => {
+      var t;
+      o.filterMethod ? o.filterMethod(e) : o.remoteMethod ? o.remoteMethod(e) : (t = s.value) == null || t.filter(e);
+    }
+  };
+};
+export {
+  j as useSelect
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/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@4.18.1/node_modules/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/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/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@4.18.1/node_modules/lodash-es/isEqual.js";
+import q from "../../../../../../../lodash-es@4.18.1/node_modules/lodash-es/pick.js";
+import B from "../../../../../../../lodash-es@4.18.1/node_modules/lodash-es/isNil.js";
+import { isFunction as G } from "../../../../../../../@vue_shared@3.5.40/node_modules/@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/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/tree-select/src/utils.js

@@ -0,0 +1,38 @@
+import { isArray as d } from "../../../../../../../@vue_shared@3.5.40/node_modules/@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
+};