@duxweb/dvha-naiveui 1.0.10 → 1.0.12

package/dist/esm/node_modules/.pnpm/naive-ui@2.42.0_vue@3.5.17_typescript@5.8.3_/node_modules/naive-ui/es/tree/src/TreeNode.js

@@ -0,0 +1,377 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { renderDropMark as j } from "./dnd.js";
+import { treeInjectionKey as V } from "./interface.js";
+import W from "./TreeNodeCheckbox.js";
+import X from "./TreeNodeContent.js";
+import Y from "./TreeNodeSwitcher.js";
+import { isNodeDisabled as Z } from "./utils.js";
+import { createDataKey as ee } from "../../_utils/vue/create-data-key.js";
+import l from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/use-memo.js";
+import { repeat as ne } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/misc/index.js";
+import { happensIn as D } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/happens-in.js";
+import { defineComponent as te, h as a, inject as de, computed as F, onMounted as ie } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import { ref as le } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+const Ne = te({
+  name: "TreeNode",
+  props: {
+    clsPrefix: {
+      type: String,
+      required: !0
+    },
+    tmNode: {
+      type: Object,
+      required: !0
+    }
+  },
+  setup(t) {
+    const e = de(V), {
+      droppingNodeParentRef: m,
+      droppingMouseNodeRef: y,
+      draggingNodeRef: b,
+      droppingPositionRef: c,
+      droppingOffsetLevelRef: p,
+      nodePropsRef: x,
+      indentRef: h,
+      blockLineRef: s,
+      checkboxPlacementRef: f,
+      checkOnClickRef: w,
+      disabledFieldRef: u,
+      showLineRef: N,
+      renderSwitcherIconRef: L,
+      overrideDefaultNodeClickBehaviorRef: v
+    } = e, P = l(() => !!t.tmNode.rawNode.checkboxDisabled), R = l(() => Z(t.tmNode, u.value)), C = l(() => e.disabledRef.value || R.value), k = F(() => {
+      const {
+        value: n
+      } = x;
+      if (n)
+        return n({
+          option: t.tmNode.rawNode
+        });
+    }), g = le(null), K = {
+      value: null
+    };
+    ie(() => {
+      K.value = g.value.$el;
+    });
+    function O() {
+      const n = () => {
+        const {
+          tmNode: d
+        } = t;
+        if (!d.isLeaf && !d.shallowLoaded) {
+          if (!e.loadingKeysRef.value.has(d.key))
+            e.loadingKeysRef.value.add(d.key);
+          else
+            return;
+          const {
+            onLoadRef: {
+              value: i
+            }
+          } = e;
+          i && i(d.rawNode).then((o) => {
+            o !== !1 && e.handleSwitcherClick(d);
+          }).finally(() => {
+            e.loadingKeysRef.value.delete(d.key);
+          });
+        } else
+          e.handleSwitcherClick(d);
+      };
+      L.value ? setTimeout(n, 0) : n();
+    }
+    const E = l(() => !R.value && e.selectableRef.value && (e.internalTreeSelect ? e.mergedCheckStrategyRef.value !== "child" || e.multipleRef.value && e.cascadeRef.value || t.tmNode.isLeaf : !0)), T = l(() => e.checkableRef.value && (e.cascadeRef.value || e.mergedCheckStrategyRef.value !== "child" || t.tmNode.isLeaf)), S = l(() => e.displayedCheckedKeysRef.value.includes(t.tmNode.key)), M = l(() => {
+      const {
+        value: n
+      } = T;
+      if (!n) return !1;
+      const {
+        value: d
+      } = w, {
+        tmNode: i
+      } = t;
+      return typeof d == "boolean" ? !i.disabled && d : d(t.tmNode.rawNode);
+    });
+    function _(n) {
+      const {
+        value: d
+      } = e.expandOnClickRef, {
+        value: i
+      } = E, {
+        value: o
+      } = M;
+      if (!i && !d && !o || D(n, "checkbox") || D(n, "switcher")) return;
+      const {
+        tmNode: r
+      } = t;
+      i && e.handleSelect(r), d && !r.isLeaf && O(), o && $(!S.value);
+    }
+    function I(n) {
+      var d, i;
+      if (!(D(n, "checkbox") || D(n, "switcher"))) {
+        if (!C.value) {
+          const o = v.value;
+          let r = !1;
+          if (o)
+            switch (o({
+              option: t.tmNode.rawNode
+            })) {
+              case "toggleCheck":
+                r = !0, $(!S.value);
+                break;
+              case "toggleSelect":
+                r = !0, e.handleSelect(t.tmNode);
+                break;
+              case "toggleExpand":
+                r = !0, O(), r = !0;
+                break;
+              case "none":
+                r = !0, r = !0;
+                return;
+            }
+          r || _(n);
+        }
+        (i = (d = k.value) === null || d === void 0 ? void 0 : d.onClick) === null || i === void 0 || i.call(d, n);
+      }
+    }
+    function q(n) {
+      s.value || I(n);
+    }
+    function A(n) {
+      s.value && I(n);
+    }
+    function $(n) {
+      e.handleCheck(t.tmNode, n);
+    }
+    function B(n) {
+      e.handleDragStart({
+        event: n,
+        node: t.tmNode
+      });
+    }
+    function H(n) {
+      n.currentTarget === n.target && e.handleDragEnter({
+        event: n,
+        node: t.tmNode
+      });
+    }
+    function z(n) {
+      n.preventDefault(), e.handleDragOver({
+        event: n,
+        node: t.tmNode
+      });
+    }
+    function G(n) {
+      e.handleDragEnd({
+        event: n,
+        node: t.tmNode
+      });
+    }
+    function J(n) {
+      n.currentTarget === n.target && e.handleDragLeave({
+        event: n,
+        node: t.tmNode
+      });
+    }
+    function Q(n) {
+      n.preventDefault(), c.value !== null && e.handleDrop({
+        event: n,
+        node: t.tmNode,
+        dropPosition: c.value
+      });
+    }
+    const U = F(() => {
+      const {
+        clsPrefix: n
+      } = t, {
+        value: d
+      } = h;
+      if (N.value) {
+        const i = [];
+        let o = t.tmNode.parent;
+        for (; o; )
+          o.isLastChild ? i.push(a("div", {
+            class: `${n}-tree-node-indent`
+          }, a("div", {
+            style: {
+              width: `${d}px`
+            }
+          }))) : i.push(a("div", {
+            class: [`${n}-tree-node-indent`, `${n}-tree-node-indent--show-line`]
+          }, a("div", {
+            style: {
+              width: `${d}px`
+            }
+          }))), o = o.parent;
+        return i.reverse();
+      } else
+        return ne(t.tmNode.level, a("div", {
+          class: `${t.clsPrefix}-tree-node-indent`
+        }, a("div", {
+          style: {
+            width: `${d}px`
+          }
+        })));
+    });
+    return {
+      showDropMark: l(() => {
+        const {
+          value: n
+        } = b;
+        if (!n) return;
+        const {
+          value: d
+        } = c;
+        if (!d) return;
+        const {
+          value: i
+        } = y;
+        if (!i)
+          return;
+        const {
+          tmNode: o
+        } = t;
+        return o.key === i.key;
+      }),
+      showDropMarkAsParent: l(() => {
+        const {
+          value: n
+        } = m;
+        if (!n) return !1;
+        const {
+          tmNode: d
+        } = t, {
+          value: i
+        } = c;
+        return i === "before" || i === "after" ? n.key === d.key : !1;
+      }),
+      pending: l(() => e.pendingNodeKeyRef.value === t.tmNode.key),
+      loading: l(() => e.loadingKeysRef.value.has(t.tmNode.key)),
+      highlight: l(() => {
+        var n;
+        return (n = e.highlightKeySetRef.value) === null || n === void 0 ? void 0 : n.has(t.tmNode.key);
+      }),
+      checked: S,
+      indeterminate: l(() => e.displayedIndeterminateKeysRef.value.includes(t.tmNode.key)),
+      selected: l(() => e.mergedSelectedKeysRef.value.includes(t.tmNode.key)),
+      expanded: l(() => e.mergedExpandedKeysRef.value.includes(t.tmNode.key)),
+      disabled: C,
+      checkable: T,
+      mergedCheckOnClick: M,
+      checkboxDisabled: P,
+      selectable: E,
+      expandOnClick: e.expandOnClickRef,
+      internalScrollable: e.internalScrollableRef,
+      draggable: e.draggableRef,
+      blockLine: s,
+      nodeProps: k,
+      checkboxFocusable: e.internalCheckboxFocusableRef,
+      droppingPosition: c,
+      droppingOffsetLevel: p,
+      indent: h,
+      checkboxPlacement: f,
+      showLine: N,
+      contentInstRef: g,
+      contentElRef: K,
+      indentNodes: U,
+      handleCheck: $,
+      handleDrop: Q,
+      handleDragStart: B,
+      handleDragEnter: H,
+      handleDragOver: z,
+      handleDragEnd: G,
+      handleDragLeave: J,
+      handleLineClick: A,
+      handleContentClick: q,
+      handleSwitcherClick: O
+    };
+  },
+  render() {
+    const {
+      tmNode: t,
+      clsPrefix: e,
+      checkable: m,
+      expandOnClick: y,
+      selectable: b,
+      selected: c,
+      checked: p,
+      highlight: x,
+      draggable: h,
+      blockLine: s,
+      indent: f,
+      indentNodes: w,
+      disabled: u,
+      pending: N,
+      internalScrollable: L,
+      nodeProps: v,
+      checkboxPlacement: P
+    } = this, R = h && !u ? {
+      onDragenter: this.handleDragEnter,
+      onDragleave: this.handleDragLeave,
+      onDragend: this.handleDragEnd,
+      onDrop: this.handleDrop,
+      onDragover: this.handleDragOver
+    } : void 0, C = L ? ee(t.key) : void 0, k = P === "right", g = m ? a(W, {
+      indent: f,
+      right: k,
+      focusable: this.checkboxFocusable,
+      disabled: u || this.checkboxDisabled,
+      clsPrefix: e,
+      checked: this.checked,
+      indeterminate: this.indeterminate,
+      onCheck: this.handleCheck
+    }) : null;
+    return a("div", Object.assign({
+      class: `${e}-tree-node-wrapper`
+    }, R), a("div", Object.assign({}, s ? v : void 0, {
+      class: [`${e}-tree-node`, {
+        [`${e}-tree-node--selected`]: c,
+        [`${e}-tree-node--checkable`]: m,
+        [`${e}-tree-node--highlight`]: x,
+        [`${e}-tree-node--pending`]: N,
+        [`${e}-tree-node--disabled`]: u,
+        [`${e}-tree-node--selectable`]: b,
+        [`${e}-tree-node--clickable`]: b || y || this.mergedCheckOnClick
+      }, v == null ? void 0 : v.class],
+      "data-key": C,
+      draggable: h && s,
+      onClick: this.handleLineClick,
+      onDragstart: h && s && !u ? this.handleDragStart : void 0
+    }), w, t.isLeaf && this.showLine ? a("div", {
+      class: [`${e}-tree-node-indent`, `${e}-tree-node-indent--show-line`, t.isLeaf && `${e}-tree-node-indent--is-leaf`, t.isLastChild && `${e}-tree-node-indent--last-child`]
+    }, a("div", {
+      style: {
+        width: `${f}px`
+      }
+    })) : a(Y, {
+      clsPrefix: e,
+      expanded: this.expanded,
+      selected: c,
+      loading: this.loading,
+      hide: t.isLeaf,
+      tmNode: this.tmNode,
+      indent: f,
+      onClick: this.handleSwitcherClick
+    }), k ? null : g, a(X, {
+      ref: "contentInstRef",
+      clsPrefix: e,
+      checked: p,
+      selected: c,
+      onClick: this.handleContentClick,
+      nodeProps: s ? void 0 : v,
+      onDragstart: h && !s && !u ? this.handleDragStart : void 0,
+      tmNode: t
+    }), h ? this.showDropMark ? j({
+      el: this.contentElRef.value,
+      position: this.droppingPosition,
+      offsetLevel: this.droppingOffsetLevel,
+      indent: f
+    }) : this.showDropMarkAsParent ? j({
+      el: this.contentElRef.value,
+      position: "inside",
+      offsetLevel: this.droppingOffsetLevel,
+      indent: f
+    }) : null : null, k ? g : null));
+  }
+});
+export {
+  Ne as default
+};

package/dist/esm/node_modules/.pnpm/naive-ui@2.42.0_vue@3.5.17_typescript@5.8.3_/node_modules/naive-ui/es/tree/src/TreeNodeCheckbox.js

@@ -0,0 +1,69 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { treeInjectionKey as a } from "./interface.js";
+import s from "../../checkbox/src/Checkbox.js";
+import { defineComponent as m, h as c, inject as l } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+const f = m({
+  name: "NTreeNodeCheckbox",
+  props: {
+    clsPrefix: {
+      type: String,
+      required: !0
+    },
+    indent: {
+      type: Number,
+      required: !0
+    },
+    right: Boolean,
+    focusable: Boolean,
+    disabled: Boolean,
+    checked: Boolean,
+    indeterminate: Boolean,
+    onCheck: Function
+  },
+  setup(t) {
+    const o = l(a);
+    function n(e) {
+      const {
+        onCheck: r
+      } = t;
+      r && r(e);
+    }
+    function d(e) {
+      n(e);
+    }
+    return {
+      handleUpdateValue: d,
+      mergedTheme: o.mergedThemeRef
+    };
+  },
+  render() {
+    const {
+      clsPrefix: t,
+      mergedTheme: o,
+      checked: n,
+      indeterminate: d,
+      disabled: e,
+      focusable: r,
+      indent: i,
+      handleUpdateValue: h
+    } = this;
+    return c("span", {
+      class: [`${t}-tree-node-checkbox`, this.right && `${t}-tree-node-checkbox--right`],
+      style: {
+        width: `${i}px`
+      },
+      "data-checkbox": !0
+    }, c(s, {
+      focusable: r,
+      disabled: e,
+      theme: o.peers.Checkbox,
+      themeOverrides: o.peerOverrides.Checkbox,
+      checked: n,
+      indeterminate: d,
+      onUpdateChecked: h
+    }));
+  }
+});
+export {
+  f as default
+};

package/dist/esm/node_modules/.pnpm/naive-ui@2.42.0_vue@3.5.17_typescript@5.8.3_/node_modules/naive-ui/es/tree/src/TreeNodeContent.js

@@ -0,0 +1,99 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { treeInjectionKey as b } from "./interface.js";
+import { render as u } from "../../_utils/vue/render.js";
+import { defineComponent as C, h as s, inject as k } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import { ref as g } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+const j = C({
+  name: "TreeNodeContent",
+  props: {
+    clsPrefix: {
+      type: String,
+      required: !0
+    },
+    disabled: Boolean,
+    checked: Boolean,
+    selected: Boolean,
+    onClick: Function,
+    onDragstart: Function,
+    tmNode: {
+      type: Object,
+      required: !0
+    },
+    nodeProps: Object
+  },
+  setup(e) {
+    const {
+      renderLabelRef: c,
+      renderPrefixRef: n,
+      renderSuffixRef: r,
+      labelFieldRef: o
+    } = k(b), f = g(null);
+    function t(d) {
+      const {
+        onClick: l
+      } = e;
+      l && l(d);
+    }
+    function i(d) {
+      t(d);
+    }
+    return {
+      selfRef: f,
+      renderLabel: c,
+      renderPrefix: n,
+      renderSuffix: r,
+      labelField: o,
+      handleClick: i
+    };
+  },
+  render() {
+    const {
+      clsPrefix: e,
+      labelField: c,
+      nodeProps: n,
+      checked: r = !1,
+      selected: o = !1,
+      renderLabel: f,
+      renderPrefix: t,
+      renderSuffix: i,
+      handleClick: d,
+      onDragstart: l,
+      tmNode: {
+        rawNode: a,
+        rawNode: {
+          prefix: p,
+          suffix: x,
+          [c]: m
+        }
+      }
+    } = this;
+    return s("span", Object.assign({}, n, {
+      ref: "selfRef",
+      class: [`${e}-tree-node-content`, n == null ? void 0 : n.class],
+      onClick: d,
+      draggable: l === void 0 ? void 0 : !0,
+      onDragstart: l
+    }), t || p ? s("div", {
+      class: `${e}-tree-node-content__prefix`
+    }, t ? t({
+      option: a,
+      selected: o,
+      checked: r
+    }) : u(p)) : null, s("div", {
+      class: `${e}-tree-node-content__text`
+    }, f ? f({
+      option: a,
+      selected: o,
+      checked: r
+    }) : u(m)), i || x ? s("div", {
+      class: `${e}-tree-node-content__suffix`
+    }, i ? i({
+      option: a,
+      selected: o,
+      checked: r
+    }) : u(x)) : null);
+  }
+});
+export {
+  j as default
+};

package/dist/esm/node_modules/.pnpm/naive-ui@2.42.0_vue@3.5.17_typescript@5.8.3_/node_modules/naive-ui/es/tree/src/TreeNodeSwitcher.js

@@ -0,0 +1,79 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { treeInjectionKey as a } from "./interface.js";
+import s from "../../_internal/icon-switch-transition/src/IconSwitchTransition.js";
+import u from "../../_internal/loading/src/Loading.js";
+import h from "../../_internal/icon/src/Icon.js";
+import m from "../../_internal/icons/Switcher.js";
+import { defineComponent as f, inject as p, h as t } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+const I = f({
+  name: "NTreeSwitcher",
+  props: {
+    clsPrefix: {
+      type: String,
+      required: !0
+    },
+    indent: {
+      type: Number,
+      required: !0
+    },
+    expanded: Boolean,
+    selected: Boolean,
+    hide: Boolean,
+    loading: Boolean,
+    onClick: Function,
+    tmNode: {
+      type: Object,
+      required: !0
+    }
+  },
+  setup(r) {
+    const {
+      renderSwitcherIconRef: i
+    } = p(a, null);
+    return () => {
+      const {
+        clsPrefix: e,
+        expanded: o,
+        hide: d,
+        indent: c,
+        onClick: l
+      } = r;
+      return t("span", {
+        "data-switcher": !0,
+        class: [`${e}-tree-node-switcher`, o && `${e}-tree-node-switcher--expanded`, d && `${e}-tree-node-switcher--hide`],
+        style: {
+          width: `${c}px`
+        },
+        onClick: l
+      }, t("div", {
+        class: `${e}-tree-node-switcher__icon`
+      }, t(s, null, {
+        default: () => {
+          if (r.loading)
+            return t(u, {
+              clsPrefix: e,
+              key: "loading",
+              radius: 85,
+              strokeWidth: 20
+            });
+          const {
+            value: n
+          } = i;
+          return n ? n({
+            expanded: r.expanded,
+            selected: r.selected,
+            option: r.tmNode.rawNode
+          }) : t(h, {
+            clsPrefix: e,
+            key: "switcher"
+          }, {
+            default: () => t(m, null)
+          });
+        }
+      })));
+    };
+  }
+});
+export {
+  I as default
+};

package/dist/esm/node_modules/.pnpm/naive-ui@2.42.0_vue@3.5.17_typescript@5.8.3_/node_modules/naive-ui/es/tree/src/dnd.js

@@ -0,0 +1,33 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { h as s } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+function l({
+  position: o,
+  offsetLevel: t,
+  indent: i,
+  el: n
+}) {
+  const r = {
+    position: "absolute",
+    boxSizing: "border-box",
+    right: 0
+  };
+  if (o === "inside")
+    r.left = 0, r.top = 0, r.bottom = 0, r.borderRadius = "inherit", r.boxShadow = "inset 0 0 0 2px var(--n-drop-mark-color)";
+  else {
+    const e = o === "before" ? "top" : "bottom";
+    r[e] = 0, r.left = `${n.offsetLeft + 6 - t * i}px`, r.height = "2px", r.backgroundColor = "var(--n-drop-mark-color)", r.transformOrigin = e, r.borderRadius = "1px", r.transform = o === "before" ? "translateY(-4px)" : "translateY(4px)";
+  }
+  return s("div", {
+    style: r
+  });
+}
+function d({
+  dropPosition: o,
+  node: t
+}) {
+  return t.isLeaf === !1 || t.children ? !0 : o !== "inside";
+}
+export {
+  d as defaultAllowDrop,
+  l as renderDropMark
+};

package/dist/esm/node_modules/.pnpm/naive-ui@2.42.0_vue@3.5.17_typescript@5.8.3_/node_modules/naive-ui/es/tree/src/interface.js

@@ -0,0 +1,5 @@
+import { createInjectionKey as e } from "../../_utils/vue/create-injection-key.js";
+const n = e("n-tree");
+export {
+  n as treeInjectionKey
+};