@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/select/src/Select.js

@@ -0,0 +1,728 @@
+import "../../../../../../vue@3.5.17_typescript@5.8.3/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import Ue from "./styles/index.cssr.js";
+import { createValOptMap as Ne, patternMatched as N, filterOptions as Ee, createTmOptions as Le } from "./utils.js";
+import $e from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Binder.js";
+import We from "../../_internal/selection/src/Selection.js";
+import re from "../../../../../../vdirs@0.1.8_vue@3.5.17_typescript@5.8.3_/node_modules/vdirs/es/clickoutside.js";
+import Ke from "../../_internal/select-menu/src/SelectMenu.js";
+import He from "../../_mixins/use-config.js";
+import de from "../../_mixins/use-theme.js";
+import ue from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/use-merged-state.js";
+import qe from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/use-compitable.js";
+import Ge from "../../_mixins/use-locale.js";
+import Je from "../../_mixins/use-form-item.js";
+import { useThemeClass as Qe } from "../../_mixins/use-css-vars-class.js";
+import Xe from "../../../../../../vooks@0.2.12_vue@3.5.17_typescript@5.8.3_/node_modules/vooks/es/life-cycle/use-is-mounted.js";
+import { getPreciseEventTarget as Ye } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/get-precise-event-target.js";
+import { happensIn as E } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/happens-in.js";
+import { markEventEffectPerformed as Ze } from "../../_utils/event/index.js";
+import { call as m } from "../../_utils/vue/call.js";
+import { warnOnce as se } from "../../_utils/naive/warn.js";
+import et from "../styles/light.js";
+import { createTreeMate as tt } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/create.js";
+import { defineComponent as nt, h as y, withDirectives as lt, watchEffect as it, computed as g, watch as ot } from "../../../../../../@vue_runtime-core@3.5.17/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import at from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Target.js";
+import rt from "../../../../../../vueuc@0.4.64_vue@3.5.17_typescript@5.8.3_/node_modules/vueuc/es/binder/src/Follower.js";
+import { useAdjustedTo as $ } from "../../_utils/composable/use-adjusted-to.js";
+import { Transition as ut, vShow as st } from "../../../../../../@vue_runtime-dom@3.5.17/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js";
+import { ref as c, toRef as L } from "../../../../../../@vue_reactivity@3.5.17/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+const dt = Object.assign(Object.assign({}, de.props), {
+  to: $.propTo,
+  bordered: {
+    type: Boolean,
+    default: void 0
+  },
+  clearable: Boolean,
+  clearFilterAfterSelect: {
+    type: Boolean,
+    default: !0
+  },
+  options: {
+    type: Array,
+    default: () => []
+  },
+  defaultValue: {
+    type: [String, Number, Array],
+    default: null
+  },
+  keyboard: {
+    type: Boolean,
+    default: !0
+  },
+  value: [String, Number, Array],
+  placeholder: String,
+  menuProps: Object,
+  multiple: Boolean,
+  size: String,
+  menuSize: {
+    type: String
+  },
+  filterable: Boolean,
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  remote: Boolean,
+  loading: Boolean,
+  filter: Function,
+  placement: {
+    type: String,
+    default: "bottom-start"
+  },
+  widthMode: {
+    type: String,
+    default: "trigger"
+  },
+  tag: Boolean,
+  onCreate: Function,
+  fallbackOption: {
+    type: [Function, Boolean],
+    default: void 0
+  },
+  show: {
+    type: Boolean,
+    default: void 0
+  },
+  showArrow: {
+    type: Boolean,
+    default: !0
+  },
+  maxTagCount: [Number, String],
+  ellipsisTagPopoverProps: Object,
+  consistentMenuWidth: {
+    type: Boolean,
+    default: !0
+  },
+  virtualScroll: {
+    type: Boolean,
+    default: !0
+  },
+  labelField: {
+    type: String,
+    default: "label"
+  },
+  valueField: {
+    type: String,
+    default: "value"
+  },
+  childrenField: {
+    type: String,
+    default: "children"
+  },
+  renderLabel: Function,
+  renderOption: Function,
+  renderTag: Function,
+  "onUpdate:value": [Function, Array],
+  inputProps: Object,
+  nodeProps: Function,
+  ignoreComposition: {
+    type: Boolean,
+    default: !0
+  },
+  showOnFocus: Boolean,
+  // for jsx
+  onUpdateValue: [Function, Array],
+  onBlur: [Function, Array],
+  onClear: [Function, Array],
+  onFocus: [Function, Array],
+  onScroll: [Function, Array],
+  onSearch: [Function, Array],
+  onUpdateShow: [Function, Array],
+  "onUpdate:show": [Function, Array],
+  displayDirective: {
+    type: String,
+    default: "show"
+  },
+  resetMenuOnOptionsChange: {
+    type: Boolean,
+    default: !0
+  },
+  status: String,
+  showCheckmark: {
+    type: Boolean,
+    default: !0
+  },
+  /** deprecated */
+  onChange: [Function, Array],
+  items: Array
+}), Ut = nt({
+  name: "Select",
+  props: dt,
+  slots: Object,
+  setup(n) {
+    process.env.NODE_ENV !== "production" && it(() => {
+      n.items !== void 0 && se("select", "`items` is deprecated, please use `options` instead."), n.onChange !== void 0 && se("select", "`on-change` is deprecated, please use `on-update:value` instead.");
+    });
+    const {
+      mergedClsPrefixRef: f,
+      mergedBorderedRef: M,
+      namespaceRef: h,
+      inlineThemeDisabled: s
+    } = He(n), W = de("Select", "-select", Ue, et, n, f), z = c(n.defaultValue), ce = L(n, "value"), T = ue(ce, z), C = c(!1), S = c(""), j = qe(n, ["items", "options"]), p = c([]), O = c([]), K = g(() => O.value.concat(p.value).concat(j.value)), fe = g(() => {
+      const {
+        filter: e
+      } = n;
+      if (e) return e;
+      const {
+        labelField: t,
+        valueField: l
+      } = n;
+      return (r, o) => {
+        if (!o) return !1;
+        const i = o[t];
+        if (typeof i == "string")
+          return N(r, i);
+        const a = o[l];
+        return typeof a == "string" ? N(r, a) : typeof a == "number" ? N(r, String(a)) : !1;
+      };
+    }), he = g(() => {
+      if (n.remote)
+        return j.value;
+      {
+        const {
+          value: e
+        } = K, {
+          value: t
+        } = S;
+        return !t.length || !n.filterable ? e : Ee(e, fe.value, t, n.childrenField);
+      }
+    }), ve = g(() => {
+      const {
+        valueField: e,
+        childrenField: t
+      } = n, l = Le(e, t);
+      return tt(he.value, l);
+    }), H = g(() => Ne(K.value, n.valueField, n.childrenField)), A = c(!1), v = ue(L(n, "show"), A), d = c(null), q = c(null), R = c(null), {
+      localeRef: me
+    } = Ge("Select"), ge = g(() => {
+      var e;
+      return (e = n.placeholder) !== null && e !== void 0 ? e : me.value.placeholder;
+    }), B = [], _ = c(/* @__PURE__ */ new Map()), G = g(() => {
+      const {
+        fallbackOption: e
+      } = n;
+      if (e === void 0) {
+        const {
+          labelField: t,
+          valueField: l
+        } = n;
+        return (r) => ({
+          [t]: String(r),
+          [l]: r
+        });
+      }
+      return e === !1 ? !1 : (t) => Object.assign(e(t), {
+        value: t
+      });
+    });
+    function U(e) {
+      const t = n.remote, {
+        value: l
+      } = _, {
+        value: r
+      } = H, {
+        value: o
+      } = G, i = [];
+      return e.forEach((a) => {
+        if (r.has(a))
+          i.push(r.get(a));
+        else if (t && l.has(a))
+          i.push(l.get(a));
+        else if (o) {
+          const u = o(a);
+          u && i.push(u);
+        }
+      }), i;
+    }
+    const J = g(() => {
+      if (n.multiple) {
+        const {
+          value: e
+        } = T;
+        return Array.isArray(e) ? U(e) : [];
+      }
+      return null;
+    }), Q = g(() => {
+      const {
+        value: e
+      } = T;
+      return !n.multiple && !Array.isArray(e) ? e === null ? null : U([e])[0] || null : null;
+    }), I = Je(n), {
+      mergedSizeRef: pe,
+      mergedDisabledRef: V,
+      mergedStatusRef: be
+    } = I;
+    function k(e, t) {
+      const {
+        onChange: l,
+        "onUpdate:value": r,
+        onUpdateValue: o
+      } = n, {
+        nTriggerFormChange: i,
+        nTriggerFormInput: a
+      } = I;
+      l && m(l, e, t), o && m(o, e, t), r && m(r, e, t), z.value = e, i(), a();
+    }
+    function X(e) {
+      const {
+        onBlur: t
+      } = n, {
+        nTriggerFormBlur: l
+      } = I;
+      t && m(t, e), l();
+    }
+    function Oe() {
+      const {
+        onClear: e
+      } = n;
+      e && m(e);
+    }
+    function Fe(e) {
+      const {
+        onFocus: t,
+        showOnFocus: l
+      } = n, {
+        nTriggerFormFocus: r
+      } = I;
+      t && m(t, e), r(), l && P();
+    }
+    function ye(e) {
+      const {
+        onSearch: t
+      } = n;
+      t && m(t, e);
+    }
+    function Se(e) {
+      const {
+        onScroll: t
+      } = n;
+      t && m(t, e);
+    }
+    function Y() {
+      var e;
+      const {
+        remote: t,
+        multiple: l
+      } = n;
+      if (t) {
+        const {
+          value: r
+        } = _;
+        if (l) {
+          const {
+            valueField: o
+          } = n;
+          (e = J.value) === null || e === void 0 || e.forEach((i) => {
+            r.set(i[o], i);
+          });
+        } else {
+          const o = Q.value;
+          o && r.set(o[n.valueField], o);
+        }
+      }
+    }
+    function Z(e) {
+      const {
+        onUpdateShow: t,
+        "onUpdate:show": l
+      } = n;
+      t && m(t, e), l && m(l, e), A.value = e;
+    }
+    function P() {
+      V.value || (Z(!0), A.value = !0, n.filterable && oe());
+    }
+    function b() {
+      Z(!1);
+    }
+    function ee() {
+      S.value = "", O.value = B;
+    }
+    const D = c(!1);
+    function we() {
+      n.filterable && (D.value = !0);
+    }
+    function Me() {
+      n.filterable && (D.value = !1, v.value || ee());
+    }
+    function Te() {
+      V.value || (v.value ? n.filterable ? oe() : b() : P());
+    }
+    function Ce(e) {
+      var t, l;
+      !((l = (t = R.value) === null || t === void 0 ? void 0 : t.selfRef) === null || l === void 0) && l.contains(e.relatedTarget) || (C.value = !1, X(e), b());
+    }
+    function Re(e) {
+      Fe(e), C.value = !0;
+    }
+    function Be() {
+      C.value = !0;
+    }
+    function Pe(e) {
+      var t;
+      !((t = d.value) === null || t === void 0) && t.$el.contains(e.relatedTarget) || (C.value = !1, X(e), b());
+    }
+    function Ae() {
+      var e;
+      (e = d.value) === null || e === void 0 || e.focus(), b();
+    }
+    function _e(e) {
+      var t;
+      v.value && (!((t = d.value) === null || t === void 0) && t.$el.contains(Ye(e)) || b());
+    }
+    function Ie(e) {
+      if (!Array.isArray(e)) return [];
+      if (G.value)
+        return Array.from(e);
+      {
+        const {
+          remote: t
+        } = n, {
+          value: l
+        } = H;
+        if (t) {
+          const {
+            value: r
+          } = _;
+          return e.filter((o) => l.has(o) || r.has(o));
+        } else
+          return e.filter((r) => l.has(r));
+      }
+    }
+    function te(e) {
+      x(e.rawNode);
+    }
+    function x(e) {
+      if (V.value) return;
+      const {
+        tag: t,
+        remote: l,
+        clearFilterAfterSelect: r,
+        valueField: o
+      } = n;
+      if (t && !l) {
+        const {
+          value: i
+        } = O, a = i[0] || null;
+        if (a) {
+          const u = p.value;
+          u.length ? u.push(a) : p.value = [a], O.value = B;
+        }
+      }
+      if (l && _.value.set(e[o], e), n.multiple) {
+        const i = Ie(T.value), a = i.findIndex((u) => u === e[o]);
+        if (~a) {
+          if (i.splice(a, 1), t && !l) {
+            const u = ne(e[o]);
+            ~u && (p.value.splice(u, 1), r && (S.value = ""));
+          }
+        } else
+          i.push(e[o]), r && (S.value = "");
+        k(i, U(i));
+      } else {
+        if (t && !l) {
+          const i = ne(e[o]);
+          ~i ? p.value = [p.value[i]] : p.value = B;
+        }
+        ie(), b(), k(e[o], e);
+      }
+    }
+    function ne(e) {
+      return p.value.findIndex((l) => l[n.valueField] === e);
+    }
+    function Ve(e) {
+      v.value || P();
+      const {
+        value: t
+      } = e.target;
+      S.value = t;
+      const {
+        tag: l,
+        remote: r
+      } = n;
+      if (ye(t), l && !r) {
+        if (!t) {
+          O.value = B;
+          return;
+        }
+        const {
+          onCreate: o
+        } = n, i = o ? o(t) : {
+          [n.labelField]: t,
+          [n.valueField]: t
+        }, {
+          valueField: a,
+          labelField: u
+        } = n;
+        j.value.some((F) => F[a] === i[a] || F[u] === i[u]) || p.value.some((F) => F[a] === i[a] || F[u] === i[u]) ? O.value = B : O.value = [i];
+      }
+    }
+    function ke(e) {
+      e.stopPropagation();
+      const {
+        multiple: t
+      } = n;
+      !t && n.filterable && b(), Oe(), t ? k([], []) : k(null, null);
+    }
+    function De(e) {
+      !E(e, "action") && !E(e, "empty") && !E(e, "header") && e.preventDefault();
+    }
+    function xe(e) {
+      Se(e);
+    }
+    function le(e) {
+      var t, l, r, o, i;
+      if (!n.keyboard) {
+        e.preventDefault();
+        return;
+      }
+      switch (e.key) {
+        case " ":
+          if (n.filterable)
+            break;
+          e.preventDefault();
+        // eslint-disable-next-line no-fallthrough
+        case "Enter":
+          if (!(!((t = d.value) === null || t === void 0) && t.isComposing)) {
+            if (v.value) {
+              const a = (l = R.value) === null || l === void 0 ? void 0 : l.getPendingTmNode();
+              a ? te(a) : n.filterable || (b(), ie());
+            } else if (P(), n.tag && D.value) {
+              const a = O.value[0];
+              if (a) {
+                const u = a[n.valueField], {
+                  value: F
+                } = T;
+                n.multiple && Array.isArray(F) && F.includes(u) || x(a);
+              }
+            }
+          }
+          e.preventDefault();
+          break;
+        case "ArrowUp":
+          if (e.preventDefault(), n.loading) return;
+          v.value && ((r = R.value) === null || r === void 0 || r.prev());
+          break;
+        case "ArrowDown":
+          if (e.preventDefault(), n.loading) return;
+          v.value ? (o = R.value) === null || o === void 0 || o.next() : P();
+          break;
+        case "Escape":
+          v.value && (Ze(e), b()), (i = d.value) === null || i === void 0 || i.focus();
+          break;
+      }
+    }
+    function ie() {
+      var e;
+      (e = d.value) === null || e === void 0 || e.focus();
+    }
+    function oe() {
+      var e;
+      (e = d.value) === null || e === void 0 || e.focusInput();
+    }
+    function ze() {
+      var e;
+      v.value && ((e = q.value) === null || e === void 0 || e.syncPosition());
+    }
+    Y(), ot(L(n, "options"), Y);
+    const je = {
+      focus: () => {
+        var e;
+        (e = d.value) === null || e === void 0 || e.focus();
+      },
+      focusInput: () => {
+        var e;
+        (e = d.value) === null || e === void 0 || e.focusInput();
+      },
+      blur: () => {
+        var e;
+        (e = d.value) === null || e === void 0 || e.blur();
+      },
+      blurInput: () => {
+        var e;
+        (e = d.value) === null || e === void 0 || e.blurInput();
+      }
+    }, ae = g(() => {
+      const {
+        self: {
+          menuBoxShadow: e
+        }
+      } = W.value;
+      return {
+        "--n-menu-box-shadow": e
+      };
+    }), w = s ? Qe("select", void 0, ae, n) : void 0;
+    return Object.assign(Object.assign({}, je), {
+      mergedStatus: be,
+      mergedClsPrefix: f,
+      mergedBordered: M,
+      namespace: h,
+      treeMate: ve,
+      isMounted: Xe(),
+      triggerRef: d,
+      menuRef: R,
+      pattern: S,
+      uncontrolledShow: A,
+      mergedShow: v,
+      adjustedTo: $(n),
+      uncontrolledValue: z,
+      mergedValue: T,
+      followerRef: q,
+      localizedPlaceholder: ge,
+      selectedOption: Q,
+      selectedOptions: J,
+      mergedSize: pe,
+      mergedDisabled: V,
+      focused: C,
+      activeWithoutMenuOpen: D,
+      inlineThemeDisabled: s,
+      onTriggerInputFocus: we,
+      onTriggerInputBlur: Me,
+      handleTriggerOrMenuResize: ze,
+      handleMenuFocus: Be,
+      handleMenuBlur: Pe,
+      handleMenuTabOut: Ae,
+      handleTriggerClick: Te,
+      handleToggle: te,
+      handleDeleteOption: x,
+      handlePatternInput: Ve,
+      handleClear: ke,
+      handleTriggerBlur: Ce,
+      handleTriggerFocus: Re,
+      handleKeydown: le,
+      handleMenuAfterLeave: ee,
+      handleMenuClickOutside: _e,
+      handleMenuScroll: xe,
+      handleMenuKeydown: le,
+      handleMenuMousedown: De,
+      mergedTheme: W,
+      cssVars: s ? void 0 : ae,
+      themeClass: w == null ? void 0 : w.themeClass,
+      onRender: w == null ? void 0 : w.onRender
+    });
+  },
+  render() {
+    return y("div", {
+      class: `${this.mergedClsPrefix}-select`
+    }, y($e, null, {
+      default: () => [y(at, null, {
+        default: () => y(We, {
+          ref: "triggerRef",
+          inlineThemeDisabled: this.inlineThemeDisabled,
+          status: this.mergedStatus,
+          inputProps: this.inputProps,
+          clsPrefix: this.mergedClsPrefix,
+          showArrow: this.showArrow,
+          maxTagCount: this.maxTagCount,
+          ellipsisTagPopoverProps: this.ellipsisTagPopoverProps,
+          bordered: this.mergedBordered,
+          active: this.activeWithoutMenuOpen || this.mergedShow,
+          pattern: this.pattern,
+          placeholder: this.localizedPlaceholder,
+          selectedOption: this.selectedOption,
+          selectedOptions: this.selectedOptions,
+          multiple: this.multiple,
+          renderTag: this.renderTag,
+          renderLabel: this.renderLabel,
+          filterable: this.filterable,
+          clearable: this.clearable,
+          disabled: this.mergedDisabled,
+          size: this.mergedSize,
+          theme: this.mergedTheme.peers.InternalSelection,
+          labelField: this.labelField,
+          valueField: this.valueField,
+          themeOverrides: this.mergedTheme.peerOverrides.InternalSelection,
+          loading: this.loading,
+          focused: this.focused,
+          onClick: this.handleTriggerClick,
+          onDeleteOption: this.handleDeleteOption,
+          onPatternInput: this.handlePatternInput,
+          onClear: this.handleClear,
+          onBlur: this.handleTriggerBlur,
+          onFocus: this.handleTriggerFocus,
+          onKeydown: this.handleKeydown,
+          onPatternBlur: this.onTriggerInputBlur,
+          onPatternFocus: this.onTriggerInputFocus,
+          onResize: this.handleTriggerOrMenuResize,
+          ignoreComposition: this.ignoreComposition
+        }, {
+          arrow: () => {
+            var n, f;
+            return [(f = (n = this.$slots).arrow) === null || f === void 0 ? void 0 : f.call(n)];
+          }
+        })
+      }), y(rt, {
+        ref: "followerRef",
+        show: this.mergedShow,
+        to: this.adjustedTo,
+        teleportDisabled: this.adjustedTo === $.tdkey,
+        containerClass: this.namespace,
+        width: this.consistentMenuWidth ? "target" : void 0,
+        minWidth: "target",
+        placement: this.placement
+      }, {
+        default: () => y(ut, {
+          name: "fade-in-scale-up-transition",
+          appear: this.isMounted,
+          onAfterLeave: this.handleMenuAfterLeave
+        }, {
+          default: () => {
+            var n, f, M;
+            return this.mergedShow || this.displayDirective === "show" ? ((n = this.onRender) === null || n === void 0 || n.call(this), lt(y(Ke, Object.assign({}, this.menuProps, {
+              ref: "menuRef",
+              onResize: this.handleTriggerOrMenuResize,
+              inlineThemeDisabled: this.inlineThemeDisabled,
+              virtualScroll: this.consistentMenuWidth && this.virtualScroll,
+              class: [`${this.mergedClsPrefix}-select-menu`, this.themeClass, (f = this.menuProps) === null || f === void 0 ? void 0 : f.class],
+              clsPrefix: this.mergedClsPrefix,
+              focusable: !0,
+              labelField: this.labelField,
+              valueField: this.valueField,
+              autoPending: !0,
+              nodeProps: this.nodeProps,
+              theme: this.mergedTheme.peers.InternalSelectMenu,
+              themeOverrides: this.mergedTheme.peerOverrides.InternalSelectMenu,
+              treeMate: this.treeMate,
+              multiple: this.multiple,
+              size: this.menuSize,
+              renderOption: this.renderOption,
+              renderLabel: this.renderLabel,
+              value: this.mergedValue,
+              style: [(M = this.menuProps) === null || M === void 0 ? void 0 : M.style, this.cssVars],
+              onToggle: this.handleToggle,
+              onScroll: this.handleMenuScroll,
+              onFocus: this.handleMenuFocus,
+              onBlur: this.handleMenuBlur,
+              onKeydown: this.handleMenuKeydown,
+              onTabOut: this.handleMenuTabOut,
+              onMousedown: this.handleMenuMousedown,
+              show: this.mergedShow,
+              showCheckmark: this.showCheckmark,
+              resetMenuOnOptionsChange: this.resetMenuOnOptionsChange
+            }), {
+              empty: () => {
+                var h, s;
+                return [(s = (h = this.$slots).empty) === null || s === void 0 ? void 0 : s.call(h)];
+              },
+              header: () => {
+                var h, s;
+                return [(s = (h = this.$slots).header) === null || s === void 0 ? void 0 : s.call(h)];
+              },
+              action: () => {
+                var h, s;
+                return [(s = (h = this.$slots).action) === null || s === void 0 ? void 0 : s.call(h)];
+              }
+            }), this.displayDirective === "show" ? [[st, this.mergedShow], [re, this.handleMenuClickOutside, void 0, {
+              capture: !0
+            }]] : [[re, this.handleMenuClickOutside, void 0, {
+              capture: !0
+            }]])) : null;
+          }
+        })
+      })]
+    }));
+  }
+});
+export {
+  Ut as default,
+  dt as selectProps
+};