ep-craft 0.1.34 → 0.1.35

package/dist/components/tree/src/tree.vue.js

@@ -0,0 +1,48 @@
+import s from "./tree2.vue.js";
+import { resolveComponent as p, openBlock as r, createElementBlock as n, normalizeClass as o, Fragment as i, renderList as l, createBlock as m, renderSlot as g, createElementVNode as t, toDisplayString as h, createCommentVNode as c, withDirectives as f, vShow as u } from "vue";
+import y from "../../../_virtual/_plugin-vue_export-helper.js";
+function k(e, w, E, N, S, $) {
+  const a = p("ep-tree-node");
+  return r(), n("div", {
+    ref: "el$",
+    class: o([
+      e.ns.b(),
+      e.ns.is("dragging", !!e.dragState.draggingNode),
+      e.ns.is("drop-not-allow", !e.dragState.allowDrop),
+      e.ns.is("drop-inner", e.dragState.dropType === "inner"),
+      { [e.ns.m("highlight-current")]: e.highlightCurrent }
+    ]),
+    role: "tree"
+  }, [
+    (r(!0), n(i, null, l(e.root.childNodes, (d) => (r(), m(a, {
+      key: e.getNodeKey(d),
+      node: d,
+      props: e.props,
+      accordion: e.accordion,
+      "render-after-expand": e.renderAfterExpand,
+      "show-checkbox": e.showCheckbox,
+      "render-content": e.renderContent,
+      onNodeExpand: e.handleNodeExpand
+    }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]))), 128)),
+    e.isEmpty ? (r(), n("div", {
+      key: 0,
+      class: o(e.ns.e("empty-block"))
+    }, [
+      g(e.$slots, "empty", {}, () => [
+        t("span", {
+          class: o(e.ns.e("empty-text"))
+        }, h(e.emptyText ?? e.t("el.tree.emptyText")), 3)
+      ])
+    ], 2)) : c("", !0),
+    f(t("div", {
+      ref: "dropIndicator$",
+      class: o(e.ns.e("drop-indicator"))
+    }, null, 2), [
+      [u, e.dragState.showDropIndicator]
+    ])
+  ], 2);
+}
+const D = /* @__PURE__ */ y(s, [["render", k]]);
+export {
+  D as default
+};

package/dist/components/tree/src/tree2.vue.js

@@ -0,0 +1,192 @@
+import { defineComponent as Y, ref as l, getCurrentInstance as j, computed as C, watch as c, provide as K } from "vue";
+import { isEqual as F } from "lodash-unified";
+import { useNamespace as G } from "../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { useLocale as Q } from "../../../hooks/use-locale/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 "../../form/index.js";
+import W from "./model/tree-store.js";
+import { handleCurrentChange as v, getNodeKey as X } from "./model/util.js";
+import Z from "./tree-node.vue.js";
+import { useNodeExpandEventBroadcast as V } from "./model/useNodeExpandEventBroadcast.js";
+import { useDragNodeHandler as ee } from "./model/useDragNode.js";
+import { useKeydown as te } from "./model/useKeydown.js";
+import { ROOT_TREE_INJECTION_KEY as re } from "./tokens.js";
+import { treeEmits as ne, treeProps as oe } from "./tree.js";
+import { formItemContextKey as de } from "../../form/src/constants.js";
+const Ie = Y({
+  name: "EpTree",
+  components: { EpTreeNode: Z },
+  props: oe,
+  emits: ne,
+  setup(n, a) {
+    const { t: k } = Q(), g = G("tree"), t = l(
+      new W({
+        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 s = l(t.value.root), y = l(null), m = l(null), h = l(null), { broadcastExpanded: f } = V(n), { dragState: E } = ee({
+      props: n,
+      ctx: a,
+      el$: m,
+      dropIndicator$: h,
+      store: t
+    });
+    te({ el$: m }, t);
+    const i = j(), p = C(() => {
+      let e = i == null ? void 0 : i.parent;
+      for (; e; ) {
+        if (e.type.name === "EpTreeSelect" || e.type.name === "ElTreeSelect")
+          return !0;
+        e = e.parent;
+      }
+      return !1;
+    }), T = C(() => {
+      const { childNodes: e } = s.value;
+      return (!e || e.length === 0 || e.every(({ visible: r }) => !r)) && !p.value;
+    });
+    c(
+      () => n.currentNodeKey,
+      (e) => {
+        t.value.setCurrentNodeKey(e ?? null);
+      }
+    ), c(
+      () => n.defaultCheckedKeys,
+      (e, r) => {
+        F(e, r) || t.value.setDefaultCheckedKey(e ?? []);
+      }
+    ), c(
+      () => n.defaultExpandedKeys,
+      (e) => {
+        t.value.setDefaultExpandedKeys(e ?? []);
+      }
+    ), c(
+      () => n.data,
+      (e) => {
+        t.value.setData(e);
+      },
+      { deep: !0 }
+    ), c(
+      () => 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);
+    }, w = (e) => n.nodeKey ? X(n.nodeKey, e.data) : e.id, o = (e) => {
+      if (!n.nodeKey)
+        throw new Error(`[Tree] nodeKey is required in ${e}`);
+    }, S = (e) => {
+      o("getNodePath");
+      const r = t.value.getNode(e);
+      if (!r) return [];
+      const d = [r.data];
+      let u = r.parent;
+      for (; u && u !== s.value; )
+        d.push(u.data), u = u.parent;
+      return d.reverse();
+    }, D = (e, r) => t.value.getCheckedNodes(e, r), H = (e) => t.value.getCheckedKeys(e), N = () => {
+      const e = t.value.getCurrentNode();
+      return e ? e.data : null;
+    }, I = () => {
+      o("getCurrentKey");
+      const e = N();
+      return e ? e[n.nodeKey] : null;
+    }, P = (e, r) => {
+      o("setCheckedNodes"), t.value.setCheckedNodes(e, r);
+    }, _ = (e, r) => {
+      o("setCheckedKeys"), t.value.setCheckedKeys(e, r);
+    }, q = (e, r, d = !1) => {
+      t.value.setChecked(e, r, d);
+    }, A = () => t.value.getHalfCheckedNodes(), M = () => t.value.getHalfCheckedKeys(), $ = (e, r = !0) => {
+      o("setCurrentNode"), v(t, a.emit, () => {
+        f(e), t.value.setUserCurrentNode(e, r);
+      });
+    }, z = (e = null, r = !0) => {
+      o("setCurrentKey"), v(t, a.emit, () => {
+        f(), 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, d) => {
+      f(r), a.emit("node-expand", e, r, d);
+    }, U = (e, r) => {
+      o("updateKeyChildren"), t.value.updateChildren(e, r);
+    };
+    return K(re, {
+      ctx: a,
+      props: n,
+      store: t,
+      root: s,
+      currentNode: y,
+      instance: i
+    }), K(de, void 0), {
+      ns: g,
+      // ref
+      store: t,
+      root: s,
+      currentNode: y,
+      dragState: E,
+      el$: m,
+      dropIndicator$: h,
+      // computed
+      isEmpty: T,
+      // methods
+      filter: x,
+      getNodeKey: w,
+      getNodePath: S,
+      getCheckedNodes: D,
+      getCheckedKeys: H,
+      getCurrentNode: N,
+      getCurrentKey: I,
+      setCheckedNodes: P,
+      setCheckedKeys: _,
+      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 {
+  Ie as default
+};

package/dist/components/tree-select/index.d.ts

@@ -1,4 +1,5 @@
 import type { Plugin } from 'vue';
-import { ElTreeSelect } from 'element-plus';
-export declare const EpTreeSelect: typeof ElTreeSelect & Plugin;
+import _EpTreeSelect from './src/tree-select.vue';
+export declare const EpTreeSelect: typeof _EpTreeSelect & Plugin;
 export default EpTreeSelect;
+export type { TreeSelectInstance } from './src/instance';

package/dist/components/tree-select/index.js

@@ -1,6 +1,9 @@
-import { ElTreeSelect as e } from "element-plus";
-import { withInstall as t } from "../../utils/with-install.js";
-const r = Object.assign({}, e, { name: "EpTreeSelect" }), o = t(r, "ep-tree-select");
+import { withInstall as e } from "../../utils/with-install.js";
+import t from "./src/tree-select.vue.js";
+const m = e(
+  t,
+  "ep-tree-select"
+);
 export {
-  o as EpTreeSelect
+  m as EpTreeSelect
 };

package/dist/components/tree-select/src/cache-options.d.ts

@@ -0,0 +1,20 @@
+import type { PropType } from 'vue';
+export type CacheOption = {
+    value: string | number | boolean | object;
+    currentLabel: string | number;
+    isDisabled: boolean;
+};
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    data: {
+        type: PropType<CacheOption[]>;
+        default: () => never[];
+    };
+}>, () => undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: PropType<CacheOption[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    data: CacheOption[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/tree-select/src/cache-options.js

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

package/dist/components/tree-select/src/instance.d.ts

@@ -0,0 +1,6 @@
+import type { SelectInstance } from '../../select';
+import type { TreeInstance } from '../../tree/src/instance';
+export type TreeSelectInstance = {
+    treeRef: TreeInstance;
+    selectRef: SelectInstance;
+};

package/dist/components/tree-select/src/select.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'vue';
+import type { SelectInstance } from '@element-plus/components/select';
+import type { TreeInstance } from '@element-plus/components/tree';
+export declare const useSelect: (props: any, { attrs, emit }: {
+    attrs: any;
+    emit: any;
+}, { select, tree, key, }: {
+    select: Ref<SelectInstance | undefined>;
+    tree: Ref<TreeInstance | undefined>;
+    key: Ref<string>;
+}) => any;

package/dist/components/tree-select/src/select.js

@@ -0,0 +1,92 @@
+import { watch as N, nextTick as d, onMounted as y, computed as u, toRefs as M } from "vue";
+import { useEventListener as C } from "@vueuse/core";
+import { pick as S } from "lodash-unified";
+import { EpSelect as T } from "../../select/index.js";
+import { useNamespace as V } from "../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import { getEventCode as k } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import { EVENT_CODE as n } from "../../../constants/aria.js";
+import { UPDATE_MODEL_EVENT as x } from "../../../constants/event.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";
+const F = (o, { attrs: a, emit: f }, {
+  select: s,
+  tree: l,
+  key: v
+}) => {
+  const h = V("tree-select");
+  N(
+    () => o.data,
+    () => {
+      o.filterable && d(() => {
+        var e, t;
+        (t = l.value) == null || t.filter((e = s.value) == null ? void 0 : e.states.inputValue);
+      });
+    },
+    { flush: "post" }
+  );
+  const p = (e) => {
+    var i;
+    const t = e.at(-1);
+    if (t.expanded && t.childNodes.at(-1))
+      p([t.childNodes.at(-1)]);
+    else {
+      const r = (i = l.value.el$) == null ? void 0 : i.querySelector(
+        `[data-key="${e.at(-1).key}"]`
+      );
+      r == null || r.focus({ preventScroll: !0 });
+      return;
+    }
+  };
+  return y(() => {
+    C(
+      () => {
+        var e;
+        return (e = s.value) == null ? void 0 : e.$el;
+      },
+      "keydown",
+      async (e) => {
+        const t = k(e), { dropdownMenuVisible: i } = s.value;
+        [n.down, n.up].includes(t) && i && (await d(), setTimeout(() => {
+          var r, c, m;
+          if (n.up === t) {
+            const E = l.value.store.root.childNodes;
+            p(E);
+            return;
+          }
+          (m = (c = (r = s.value.optionsArray[s.value.states.hoveringIndex].$el) == null ? void 0 : r.parentNode) == null ? void 0 : c.parentNode) == null || m.focus({ preventScroll: !0 });
+        }));
+      },
+      {
+        capture: !0
+      }
+    );
+  }), {
+    ...S(M(o), Object.keys(T.props)),
+    ...a,
+    class: u(() => a.class),
+    style: u(() => a.style),
+    // attrs is not reactive, when v-model binding source changes,
+    // this listener is still old, see the bug(or test 'v-model source change'):
+    // https://github.com/element-plus/element-plus/issues/14204
+    "onUpdate:modelValue": (e) => f(x, e),
+    valueKey: v,
+    popperClass: u(() => {
+      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 = l.value) == null || t.filter(e);
+    }
+  };
+};
+export {
+  F as useSelect
+};