@duxweb/dvha-naiveui 1.2.5 → 1.2.7

package/dist/esm/node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree/src/utils.js

@@ -0,0 +1,73 @@
+import { computed as e } from "../../../../../../@vue_runtime-core@3.5.31/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import "../../../../../../vue@3.5.31_typescript@6.0.2/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { isBrowser as t } from "../../_utils/env/is-browser.js";
+//#region ../../node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree/src/utils.mjs
+function n(t) {
+	return e(() => t.leafOnly ? "child" : t.checkStrategy);
+}
+function r(e, t) {
+	return !!e.rawNode[t];
+}
+function i(e, t, n, r) {
+	e?.forEach((e) => {
+		n(e), i(e[t], t, n, r), r(e);
+	});
+}
+function a(e, t, n, r, a) {
+	let o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), c = [];
+	return i(e, r, (e) => {
+		if (c.push(e), a(t, e)) {
+			s.add(e[n]);
+			for (let e = c.length - 2; e >= 0; --e) if (!o.has(c[e][n])) o.add(c[e][n]);
+			else return;
+		}
+	}, () => {
+		c.pop();
+	}), {
+		expandedKeys: Array.from(o),
+		highlightKeySet: s
+	};
+}
+if (t && Image) {
+	let e = new Image();
+	e.src = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
+}
+function o(e, t, n, r, i) {
+	let a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), c = [], l = [], u = [];
+	function d(e) {
+		e.forEach((e) => {
+			if (u.push(e), t(n, e)) {
+				a.add(e[r]), s.add(e[r]);
+				for (let e = u.length - 2; e >= 0; --e) {
+					let t = u[e][r];
+					if (!o.has(t)) o.add(t), a.has(t) && a.delete(t);
+					else break;
+				}
+			}
+			let c = e[i];
+			c && d(c), u.pop();
+		});
+	}
+	d(e);
+	function f(e, t) {
+		e.forEach((e) => {
+			let n = e[r], s = a.has(n), l = o.has(n);
+			if (!s && !l) return;
+			let u = e[i];
+			if (u) if (s) t.push(e);
+			else {
+				c.push(n);
+				let r = Object.assign(Object.assign({}, e), { [i]: [] });
+				t.push(r), f(u, r[i]);
+			}
+			else t.push(e);
+		});
+	}
+	return f(e, l), {
+		filteredTree: l,
+		highlightKeySet: s,
+		expandedKeys: c
+	};
+}
+//#endregion
+export { o as filterTree, r as isNodeDisabled, a as keysWithFilter, n as useMergedCheckStrategy };

package/dist/esm/node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree/styles/light.js

@@ -0,0 +1,38 @@
+import { changeColor as e } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/color/index.js";
+import { createTheme as t } from "../../_mixins/use-theme.js";
+import n from "../../_styles/common/light.js";
+import r from "../../_internal/scrollbar/styles/light.js";
+import i from "../../empty/styles/light.js";
+import a from "../../checkbox/styles/light.js";
+//#region ../../node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree/styles/light.mjs
+function o(t) {
+	let { borderRadiusSmall: n, dividerColor: r, hoverColor: i, pressedColor: a, primaryColor: o, textColor3: s, textColor2: c, textColorDisabled: l, fontSize: u } = t;
+	return {
+		fontSize: u,
+		lineHeight: "1.5",
+		nodeHeight: "30px",
+		nodeWrapperPadding: "3px 0",
+		nodeBorderRadius: n,
+		nodeColorHover: i,
+		nodeColorPressed: a,
+		nodeColorActive: e(o, { alpha: .1 }),
+		arrowColor: s,
+		nodeTextColor: c,
+		nodeTextColorDisabled: l,
+		loadingColor: o,
+		dropMarkColor: o,
+		lineColor: r
+	};
+}
+var s = t({
+	name: "Tree",
+	common: n,
+	peers: {
+		Checkbox: a,
+		Scrollbar: r,
+		Empty: i
+	},
+	self: o
+});
+//#endregion
+export { s as default };

package/dist/esm/node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree-select/src/TreeSelect.js

@@ -0,0 +1,580 @@
+import { ref as e, toRef as t } from "../../../../../../@vue_reactivity@3.5.31/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+import { computed as n, defineComponent as r, h as i, provide as a, watchEffect as o, withDirectives as s } from "../../../../../../@vue_runtime-core@3.5.31/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js";
+import { Transition as c } from "../../../../../../@vue_runtime-dom@3.5.31/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js";
+import "../../../../../../vue@3.5.31_typescript@6.0.2/node_modules/vue/dist/vue.runtime.esm-bundler.js";
+import { happensIn as l } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/happens-in.js";
+import { getPreciseEventTarget as u } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/get-precise-event-target.js";
+import d from "../../../../../../vooks@0.2.12_vue@3.5.31_typescript@6.0.2_/node_modules/vooks/es/use-merged-state.js";
+import ee from "../../../../../../vooks@0.2.12_vue@3.5.31_typescript@6.0.2_/node_modules/vooks/es/life-cycle/use-is-mounted.js";
+import { useAdjustedTo as f } from "../../_utils/composable/use-adjusted-to.js";
+import p from "../../../../../../vueuc@0.4.65_vue@3.5.31_typescript@6.0.2_/node_modules/vueuc/es/binder/src/Binder.js";
+import m from "../../../../../../vueuc@0.4.65_vue@3.5.31_typescript@6.0.2_/node_modules/vueuc/es/binder/src/Target.js";
+import h from "../../../../../../vdirs@0.1.8_vue@3.5.31_typescript@6.0.2_/node_modules/vdirs/es/clickoutside.js";
+import g from "../../../../../../vueuc@0.4.65_vue@3.5.31_typescript@6.0.2_/node_modules/vueuc/es/binder/src/Follower.js";
+import { useOnResize as te } from "../../_utils/composable/use-resize.js";
+import { markEventEffectPerformed as ne } from "../../_utils/event/index.js";
+import { warnOnce as re } from "../../_utils/naive/warn.js";
+import { call as _ } from "../../_utils/vue/call.js";
+import { resolveSlot as v, resolveWrappedSlot as y } from "../../_utils/vue/resolve-slot.js";
+import ie from "../../_mixins/use-config.js";
+import { useThemeClass as ae } from "../../_mixins/use-css-vars-class.js";
+import oe from "../../_mixins/use-form-item.js";
+import se from "../../_mixins/use-locale.js";
+import b from "../../_mixins/use-theme.js";
+import x from "../../_internal/focus-detector/index.js";
+import { createTreeMate as ce } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/create.js";
+import S from "../../empty/src/Empty.js";
+import le from "../../_internal/selection/src/Selection.js";
+import ue from "../styles/light.js";
+import { treeSelectInjectionKey as de } from "./interface.js";
+import { useMergedCheckStrategy as fe } from "../../tree/src/utils.js";
+import C, { createTreeMateOptions as pe, treeSharedProps as w } from "../../tree/src/Tree.js";
+import me from "./styles/index.cssr.js";
+import { treeOption2SelectOption as T, treeOption2SelectOptionWithPath as E } from "./utils.js";
+var D = r({
+	name: "TreeSelect",
+	props: Object.assign(Object.assign(Object.assign(Object.assign({}, b.props), {
+		bordered: {
+			type: Boolean,
+			default: !0
+		},
+		cascade: Boolean,
+		checkable: Boolean,
+		clearable: Boolean,
+		clearFilterAfterSelect: {
+			type: Boolean,
+			default: !0
+		},
+		consistentMenuWidth: {
+			type: Boolean,
+			default: !0
+		},
+		defaultShow: Boolean,
+		defaultValue: {
+			type: [
+				String,
+				Number,
+				Array
+			],
+			default: null
+		},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		filterable: Boolean,
+		checkStrategy: {
+			type: String,
+			default: "all"
+		},
+		loading: Boolean,
+		maxTagCount: [String, Number],
+		multiple: Boolean,
+		showLine: Boolean,
+		showPath: Boolean,
+		separator: {
+			type: String,
+			default: " / "
+		},
+		options: {
+			type: Array,
+			default: () => []
+		},
+		placeholder: String,
+		placement: {
+			type: String,
+			default: "bottom-start"
+		},
+		show: {
+			type: Boolean,
+			default: void 0
+		},
+		size: String,
+		value: [
+			String,
+			Number,
+			Array
+		],
+		to: f.propTo,
+		menuProps: Object,
+		virtualScroll: {
+			type: Boolean,
+			default: !0
+		},
+		status: String,
+		renderTag: Function,
+		ellipsisTagPopoverProps: Object
+	}), w), {
+		renderLabel: Function,
+		renderPrefix: Function,
+		renderSuffix: Function,
+		nodeProps: Function,
+		watchProps: Array,
+		getChildren: Function,
+		onBlur: Function,
+		onFocus: Function,
+		onLoad: Function,
+		onUpdateShow: [Function, Array],
+		onUpdateValue: [Function, Array],
+		"onUpdate:value": [Function, Array],
+		"onUpdate:show": [Function, Array],
+		leafOnly: Boolean
+	}),
+	slots: Object,
+	setup(r) {
+		process.env.NODE_ENV !== "production" && o(() => {
+			r.leafOnly && re("tree-select", "`leaf-only` is deprecated, please use `check-strategy=\"child\"` instead.");
+		});
+		let i = e(null), s = e(null), c = e(null), p = e(null), { mergedClsPrefixRef: m, namespaceRef: h, inlineThemeDisabled: g, mergedComponentPropsRef: v } = ie(r), { localeRef: y } = se("Select"), { mergedSizeRef: x, mergedDisabledRef: S, mergedStatusRef: le, nTriggerFormBlur: C, nTriggerFormChange: w, nTriggerFormFocus: D, nTriggerFormInput: he } = oe(r, { mergedSize: (e) => {
+			let { size: t } = r;
+			if (t) return t;
+			let { mergedSize: n } = e || {};
+			return n?.value ? n.value : v?.value?.TreeSelect?.size || "medium";
+		} }), O = e(r.defaultValue), k = d(t(r, "value"), O), A = e(r.defaultShow), j = d(t(r, "show"), A), M = e(""), ge = n(() => {
+			let { filter: e } = r;
+			if (e) return e;
+			let { labelField: t } = r;
+			return (e, n) => e.length ? n[t].toLowerCase().includes(e.toLowerCase()) : !0;
+		}), N = n(() => ce(r.options, pe(r.keyField, r.childrenField, r.disabledField, void 0))), { value: P } = k, F = e(r.checkable ? null : Array.isArray(P) && P.length ? P[P.length - 1] : null), I = n(() => r.multiple && r.cascade && r.checkable), L = e(r.defaultExpandAll ? void 0 : r.defaultExpandedKeys || r.expandedKeys), _e = d(t(r, "expandedKeys"), L), R = e(!1), ve = n(() => {
+			let { placeholder: e } = r;
+			return e === void 0 ? y.value.placeholder : e;
+		}), z = n(() => {
+			let { value: e } = k;
+			return r.multiple ? Array.isArray(e) ? e : [] : e === null || Array.isArray(e) ? [] : [e];
+		}), ye = n(() => r.checkable ? [] : z.value), be = n(() => {
+			let { multiple: e, showPath: t, separator: n, labelField: i } = r;
+			if (e) return null;
+			let { value: a } = k;
+			if (!Array.isArray(a) && a !== null) {
+				let { value: e } = N, r = e.getNode(a);
+				if (r !== null) return t ? E(r, e.getPath(a).treeNodePath, n, i) : T(r, i);
+			}
+			return null;
+		}), xe = n(() => {
+			let { multiple: e, showPath: t, separator: n } = r;
+			if (!e) return null;
+			let { value: i } = k;
+			if (Array.isArray(i)) {
+				let e = [], { value: a } = N, { checkedKeys: o } = a.getCheckedKeys(i, {
+					checkStrategy: r.checkStrategy,
+					cascade: I.value,
+					allowNotLoaded: r.allowCheckingNotLoaded
+				}), { labelField: s } = r;
+				return o.forEach((r) => {
+					let i = a.getNode(r);
+					i !== null && e.push(t ? E(i, a.getPath(r).treeNodePath, n, s) : T(i, s));
+				}), e;
+			}
+			return [];
+		});
+		function B() {
+			var e;
+			(e = s.value) == null || e.focus();
+		}
+		function V() {
+			var e;
+			(e = s.value) == null || e.focusInput();
+		}
+		function H(e) {
+			let { onUpdateShow: t, "onUpdate:show": n } = r;
+			t && _(t, e), n && _(n, e), A.value = e;
+		}
+		function U(e, t, n) {
+			let { onUpdateValue: i, "onUpdate:value": a } = r;
+			i && _(i, e, t, n), a && _(a, e, t, n), O.value = e, he(), w();
+		}
+		function Se(e, t) {
+			let { onUpdateIndeterminateKeys: n, "onUpdate:indeterminateKeys": i } = r;
+			n && _(n, e, t), i && _(i, e, t);
+		}
+		function Ce(e, t, n) {
+			let { onUpdateExpandedKeys: i, "onUpdate:expandedKeys": a } = r;
+			i && _(i, e, t, n), a && _(a, e, t, n), L.value = e;
+		}
+		function W(e) {
+			let { onFocus: t } = r;
+			t && t(e), D();
+		}
+		function G(e) {
+			K();
+			let { onBlur: t } = r;
+			t && t(e), C();
+		}
+		function K() {
+			H(!1);
+		}
+		function q() {
+			S.value || (M.value = "", H(!0), r.filterable && V());
+		}
+		function we() {
+			M.value = "";
+		}
+		function Te(e) {
+			j.value && (s.value?.$el.contains(u(e)) || K());
+		}
+		function Ee() {
+			S.value || (j.value ? r.filterable || K() : q());
+		}
+		function J(e) {
+			let { value: { getNode: t } } = N;
+			return e.map((e) => t(e)?.rawNode || null);
+		}
+		function De(e, t, n) {
+			let i = J(e), a = n.action === "check" ? "select" : "unselect", o = n.node;
+			r.multiple ? (U(e, i, {
+				node: o,
+				action: a
+			}), r.filterable && (V(), r.clearFilterAfterSelect && (M.value = ""))) : (e.length ? U(e[0], i[0] || null, {
+				node: o,
+				action: a
+			}) : U(null, null, {
+				node: o,
+				action: a
+			}), K(), B());
+		}
+		function Oe(e) {
+			r.checkable && Se(e, J(e));
+		}
+		function ke(e) {
+			p.value?.contains(e.relatedTarget) || (R.value = !0, W(e));
+		}
+		function Ae(e) {
+			p.value?.contains(e.relatedTarget) || (R.value = !1, G(e));
+		}
+		function je(e) {
+			p.value?.contains(e.relatedTarget) || (s.value?.$el)?.contains(e.relatedTarget) || (R.value = !0, W(e));
+		}
+		function Me(e) {
+			p.value?.contains(e.relatedTarget) || (s.value?.$el)?.contains(e.relatedTarget) || (R.value = !1, G(e));
+		}
+		function Ne(e) {
+			e.stopPropagation();
+			let { multiple: t } = r;
+			!t && r.filterable && K(), t ? U([], [], {
+				node: null,
+				action: "clear"
+			}) : U(null, null, {
+				node: null,
+				action: "clear"
+			});
+		}
+		function Pe(e) {
+			let { value: t } = k;
+			if (Array.isArray(t)) {
+				let { value: n } = N, { checkedKeys: i } = n.getCheckedKeys(t, {
+					cascade: I.value,
+					allowNotLoaded: r.allowCheckingNotLoaded
+				}), a = i.findIndex((t) => t === e.value);
+				if (~a) {
+					let t = i[a], o = J([t])[0];
+					if (r.checkable) {
+						let { checkedKeys: t } = n.uncheck(e.value, i, {
+							checkStrategy: r.checkStrategy,
+							cascade: I.value,
+							allowNotLoaded: r.allowCheckingNotLoaded
+						});
+						U(t, J(t), {
+							node: o,
+							action: "delete"
+						});
+					} else {
+						let e = Array.from(i);
+						e.splice(a, 1), U(e, J(e), {
+							node: o,
+							action: "delete"
+						});
+					}
+				}
+			}
+		}
+		function Fe(e) {
+			let { value: t } = e.target;
+			M.value = t;
+		}
+		function Y(e) {
+			let { value: t } = c;
+			return t ? t.handleKeydown(e) : { enterBehavior: null };
+		}
+		function Ie(e) {
+			if (e.key === "Enter") {
+				if (j.value) {
+					let { enterBehavior: t } = Y(e);
+					if (!r.multiple) switch (t) {
+						case "default":
+						case "toggleSelect":
+							K(), B();
+							break;
+						default: break;
+					}
+				} else q();
+				e.preventDefault();
+			} else e.key === "Escape" ? j.value && (ne(e), K(), B()) : j.value ? Y(e) : e.key === "ArrowDown" && q();
+		}
+		function Le() {
+			K(), B();
+		}
+		function Re(e) {
+			!l(e, "action") && !l(e, "header") && e.preventDefault();
+		}
+		let ze = n(() => {
+			let { renderTag: e } = r;
+			if (e) return function({ option: t, handleClose: n }) {
+				let { value: r } = t;
+				if (r !== void 0) {
+					let t = N.value.getNode(r);
+					if (t) return e({
+						option: t.rawNode,
+						handleClose: n
+					});
+				}
+				return r;
+			};
+		});
+		a(de, {
+			pendingNodeKeyRef: F,
+			dataTreeMate: N
+		});
+		function X() {
+			var e;
+			j.value && ((e = i.value) == null || e.syncPosition());
+		}
+		te(p, X);
+		let Be = fe(r), Z = n(() => {
+			if (r.checkable) {
+				let e = k.value;
+				return r.multiple && Array.isArray(e) ? N.value.getCheckedKeys(e, {
+					cascade: r.cascade,
+					checkStrategy: Be.value,
+					allowNotLoaded: r.allowCheckingNotLoaded
+				}) : {
+					checkedKeys: Array.isArray(e) || e === null ? [] : [e],
+					indeterminateKeys: []
+				};
+			}
+			return {
+				checkedKeys: [],
+				indeterminateKeys: []
+			};
+		}), Ve = {
+			getCheckedData: () => {
+				let { checkedKeys: e } = Z.value;
+				return {
+					keys: e,
+					options: J(e)
+				};
+			},
+			getIndeterminateData: () => {
+				let { indeterminateKeys: e } = Z.value;
+				return {
+					keys: e,
+					options: J(e)
+				};
+			},
+			focus: () => s.value?.focus(),
+			focusInput: () => s.value?.focusInput(),
+			blur: () => s.value?.blur(),
+			blurInput: () => s.value?.blurInput()
+		}, Q = b("TreeSelect", "-tree-select", me, ue, r, m), He = n(() => v?.value?.TreeSelect?.renderEmpty), Ue = n(() => {
+			let { common: { cubicBezierEaseInOut: e }, self: { menuBoxShadow: t, menuBorderRadius: n, menuColor: r, menuHeight: i, actionPadding: a, actionDividerColor: o, actionTextColor: s, headerDividerColor: c, headerPadding: l, headerTextColor: u } } = Q.value;
+			return {
+				"--n-menu-box-shadow": t,
+				"--n-menu-border-radius": n,
+				"--n-menu-color": r,
+				"--n-menu-height": i,
+				"--n-bezier": e,
+				"--n-action-padding": a,
+				"--n-action-text-color": s,
+				"--n-action-divider-color": o,
+				"--n-header-padding": l,
+				"--n-header-text-color": u,
+				"--n-header-divider-color": c
+			};
+		}), $ = g ? ae("tree-select", void 0, Ue, r) : void 0, We = n(() => {
+			let { self: { menuPadding: e } } = Q.value;
+			return e;
+		});
+		return Object.assign(Object.assign({}, Ve), {
+			menuElRef: p,
+			mergedStatus: le,
+			triggerInstRef: s,
+			followerInstRef: i,
+			treeInstRef: c,
+			mergedClsPrefix: m,
+			mergedValue: k,
+			mergedShow: j,
+			namespace: h,
+			adjustedTo: f(r),
+			isMounted: ee(),
+			focused: R,
+			menuPadding: We,
+			mergedPlaceholder: ve,
+			mergedExpandedKeys: _e,
+			treeSelectedKeys: ye,
+			treeCheckedKeys: z,
+			mergedSize: x,
+			mergedDisabled: S,
+			selectedOption: be,
+			selectedOptions: xe,
+			pattern: M,
+			pendingNodeKey: F,
+			mergedCascade: I,
+			mergedFilter: ge,
+			selectionRenderTag: ze,
+			handleTriggerOrMenuResize: X,
+			doUpdateExpandedKeys: Ce,
+			handleMenuLeave: we,
+			handleTriggerClick: Ee,
+			handleMenuClickoutside: Te,
+			handleUpdateCheckedKeys: De,
+			handleUpdateIndeterminateKeys: Oe,
+			handleTriggerFocus: ke,
+			handleTriggerBlur: Ae,
+			handleMenuFocusin: je,
+			handleMenuFocusout: Me,
+			handleClear: Ne,
+			handleDeleteOption: Pe,
+			handlePatternInput: Fe,
+			handleKeydown: Ie,
+			handleTabOut: Le,
+			handleMenuMousedown: Re,
+			mergedTheme: Q,
+			mergedRenderEmpty: He,
+			cssVars: g ? void 0 : Ue,
+			themeClass: $?.themeClass,
+			onRender: $?.onRender
+		});
+	},
+	render() {
+		let { mergedTheme: e, mergedClsPrefix: t, $slots: n } = this;
+		return i("div", { class: `${t}-tree-select` }, i(p, null, { default: () => [i(m, null, { default: () => i(le, {
+			ref: "triggerInstRef",
+			onResize: this.handleTriggerOrMenuResize,
+			status: this.mergedStatus,
+			focused: this.focused,
+			clsPrefix: t,
+			theme: e.peers.InternalSelection,
+			themeOverrides: e.peerOverrides.InternalSelection,
+			ellipsisTagPopoverProps: this.ellipsisTagPopoverProps,
+			renderTag: this.selectionRenderTag,
+			selectedOption: this.selectedOption,
+			selectedOptions: this.selectedOptions,
+			size: this.mergedSize,
+			bordered: this.bordered,
+			placeholder: this.mergedPlaceholder,
+			disabled: this.mergedDisabled,
+			active: this.mergedShow,
+			loading: this.loading,
+			multiple: this.multiple,
+			maxTagCount: this.maxTagCount,
+			showArrow: !0,
+			filterable: this.filterable,
+			clearable: this.clearable,
+			pattern: this.pattern,
+			onPatternInput: this.handlePatternInput,
+			onClear: this.handleClear,
+			onClick: this.handleTriggerClick,
+			onFocus: this.handleTriggerFocus,
+			onBlur: this.handleTriggerBlur,
+			onDeleteOption: this.handleDeleteOption,
+			onKeydown: this.handleKeydown
+		}, { arrow: () => {
+			var e;
+			return [(e = this.$slots).arrow?.call(e)];
+		} }) }), i(g, {
+			ref: "followerInstRef",
+			show: this.mergedShow,
+			placement: this.placement,
+			to: this.adjustedTo,
+			teleportDisabled: this.adjustedTo === f.tdkey,
+			containerClass: this.namespace,
+			width: this.consistentMenuWidth ? "target" : void 0,
+			minWidth: "target"
+		}, { default: () => i(c, {
+			name: "fade-in-scale-up-transition",
+			appear: this.isMounted,
+			onLeave: this.handleMenuLeave
+		}, { default: () => {
+			var t;
+			if (!this.mergedShow) return null;
+			let { mergedClsPrefix: r, checkable: a, multiple: o, menuProps: c, options: l } = this;
+			return (t = this.onRender) == null || t.call(this), s(i("div", Object.assign({}, c, {
+				class: [
+					`${r}-tree-select-menu`,
+					c?.class,
+					this.themeClass
+				],
+				ref: "menuElRef",
+				style: [c?.style || "", this.cssVars],
+				tabindex: 0,
+				onMousedown: this.handleMenuMousedown,
+				onKeydown: this.handleKeydown,
+				onFocusin: this.handleMenuFocusin,
+				onFocusout: this.handleMenuFocusout
+			}), y(n.header, (e) => e ? i("div", {
+				class: `${r}-tree-select-menu__header`,
+				"data-header": !0
+			}, e) : null), i(C, {
+				ref: "treeInstRef",
+				blockLine: !0,
+				allowCheckingNotLoaded: this.allowCheckingNotLoaded,
+				showIrrelevantNodes: !1,
+				animated: !1,
+				pattern: this.pattern,
+				getChildren: this.getChildren,
+				filter: this.mergedFilter,
+				data: l,
+				cancelable: o,
+				labelField: this.labelField,
+				keyField: this.keyField,
+				disabledField: this.disabledField,
+				childrenField: this.childrenField,
+				theme: e.peers.Tree,
+				themeOverrides: e.peerOverrides.Tree,
+				defaultExpandAll: this.defaultExpandAll,
+				defaultExpandedKeys: this.defaultExpandedKeys,
+				indent: this.indent,
+				expandedKeys: this.mergedExpandedKeys,
+				checkedKeys: this.treeCheckedKeys,
+				selectedKeys: this.treeSelectedKeys,
+				checkable: a,
+				checkStrategy: this.checkStrategy,
+				cascade: this.mergedCascade,
+				leafOnly: this.leafOnly,
+				multiple: this.multiple,
+				showLine: this.showLine,
+				renderLabel: this.renderLabel,
+				renderPrefix: this.renderPrefix,
+				renderSuffix: this.renderSuffix,
+				renderSwitcherIcon: this.renderSwitcherIcon,
+				nodeProps: this.nodeProps,
+				watchProps: this.watchProps,
+				virtualScroll: this.consistentMenuWidth && this.virtualScroll,
+				overrideDefaultNodeClickBehavior: this.overrideDefaultNodeClickBehavior,
+				internalTreeSelect: !0,
+				internalUnifySelectCheck: !0,
+				internalScrollable: !0,
+				internalScrollablePadding: this.menuPadding,
+				internalFocusable: !1,
+				internalCheckboxFocusable: !1,
+				internalRenderEmpty: () => i("div", { class: `${r}-tree-select-menu__empty` }, v(n.empty, () => [this.mergedRenderEmpty?.call(this) || i(S, {
+					theme: e.peers.Empty,
+					themeOverrides: e.peerOverrides.Empty
+				})])),
+				onLoad: this.onLoad,
+				onUpdateCheckedKeys: this.handleUpdateCheckedKeys,
+				onUpdateIndeterminateKeys: this.handleUpdateIndeterminateKeys,
+				onUpdateExpandedKeys: this.doUpdateExpandedKeys
+			}), y(n.action, (e) => e ? i("div", {
+				class: `${r}-tree-select-menu__action`,
+				"data-action": !0
+			}, e) : null), i(x, { onFocus: this.handleTabOut })), [[
+				h,
+				this.handleMenuClickoutside,
+				void 0,
+				{ capture: !0 }
+			]]);
+		} }) })] }));
+	}
+});
+//#endregion
+export { D as default };

package/dist/esm/node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree-select/src/interface.js

@@ -0,0 +1,5 @@
+import { createInjectionKey as e } from "../../_utils/vue/create-injection-key.js";
+//#region ../../node_modules/.pnpm/naive-ui@2.44.1_vue@3.5.31_typescript@6.0.2_/node_modules/naive-ui/es/tree-select/src/interface.mjs
+var t = e("n-tree-select");
+//#endregion
+export { t as treeSelectInjectionKey };