@duxweb/dvha-naiveui 1.2.6 → 1.2.8

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

@@ -0,0 +1,701 @@
+import { isReactive as e, ref as t, toRef as n } from "../../../../../../@vue_reactivity@3.5.31/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js";
+import { computed as r, defineComponent as i, h as a, nextTick as o, provide as s, watch as c, watchEffect as ee } 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 { happensIn as l } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/happens-in.js";
+import { getPreciseEventTarget as te } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/dom/get-precise-event-target.js";
+import { depx as u } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/css/index.js";
+import { changeColor as ne } from "../../../../../../seemly@0.3.10/node_modules/seemly/es/color/index.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 f 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 p } from "../../_utils/composable/use-adjusted-to.js";
+import m from "../../../../../../vueuc@0.4.65_vue@3.5.31_typescript@6.0.2_/node_modules/vueuc/es/binder/src/Binder.js";
+import h from "../../../../../../vueuc@0.4.65_vue@3.5.31_typescript@6.0.2_/node_modules/vueuc/es/binder/src/Target.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 { markEventEffectPerformed as re } from "../../_utils/event/index.js";
+import { warnOnce as ie } from "../../_utils/naive/warn.js";
+import { call as _ } from "../../_utils/vue/call.js";
+import ae from "../../_mixins/use-config.js";
+import { useThemeClass as oe } from "../../_mixins/use-css-vars-class.js";
+import se from "../../_mixins/use-form-item.js";
+import ce from "../../_mixins/use-locale.js";
+import v from "../../_mixins/use-theme.js";
+import { SubtreeNotLoadedError as le } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/check.js";
+import { createTreeMate as ue } from "../../../../../../treemate@0.3.11/node_modules/treemate/es/create.js";
+import y from "../../_internal/selection/src/Selection.js";
+import de from "../styles/light.js";
+import { cascaderInjectionKey as fe } from "./interface.js";
+import pe from "./CascaderMenu.js";
+import { getPathLabel as b, getRawNodePath as x } from "./utils.js";
+import S from "./CascaderSelectMenu.js";
+import me from "./styles/index.cssr.js";
+var C = i({
+	name: "Cascader",
+	props: Object.assign(Object.assign({}, v.props), {
+		allowCheckingNotLoaded: Boolean,
+		to: p.propTo,
+		bordered: {
+			type: Boolean,
+			default: void 0
+		},
+		options: {
+			type: Array,
+			default: () => []
+		},
+		value: [
+			String,
+			Number,
+			Array
+		],
+		defaultValue: {
+			type: [
+				String,
+				Number,
+				Array
+			],
+			default: null
+		},
+		placeholder: String,
+		multiple: Boolean,
+		size: String,
+		filterable: Boolean,
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		disabledField: {
+			type: String,
+			default: "disabled"
+		},
+		expandTrigger: {
+			type: String,
+			default: "click"
+		},
+		clearable: Boolean,
+		clearFilterAfterSelect: {
+			type: Boolean,
+			default: !0
+		},
+		remote: Boolean,
+		onLoad: Function,
+		separator: {
+			type: String,
+			default: " / "
+		},
+		filter: Function,
+		placement: {
+			type: String,
+			default: "bottom-start"
+		},
+		cascade: {
+			type: Boolean,
+			default: !0
+		},
+		leafOnly: Boolean,
+		showPath: {
+			type: Boolean,
+			default: !0
+		},
+		show: {
+			type: Boolean,
+			default: void 0
+		},
+		maxTagCount: [String, Number],
+		ellipsisTagPopoverProps: Object,
+		menuProps: Object,
+		filterMenuProps: Object,
+		virtualScroll: {
+			type: Boolean,
+			default: !0
+		},
+		checkStrategy: {
+			type: String,
+			default: "all"
+		},
+		valueField: {
+			type: String,
+			default: "value"
+		},
+		labelField: {
+			type: String,
+			default: "label"
+		},
+		childrenField: {
+			type: String,
+			default: "children"
+		},
+		renderLabel: Function,
+		status: String,
+		"onUpdate:value": [Function, Array],
+		onUpdateValue: [Function, Array],
+		"onUpdate:show": [Function, Array],
+		onUpdateShow: [Function, Array],
+		onBlur: Function,
+		onFocus: Function,
+		getColumnStyle: Function,
+		spinProps: Object,
+		renderPrefix: Function,
+		renderSuffix: Function,
+		scrollbarProps: Object,
+		onChange: [Function, Array]
+	}),
+	slots: Object,
+	setup(i, { slots: a }) {
+		process.env.NODE_ENV !== "production" && ee(() => {
+			i.leafOnly && ie("cascader", "`leaf-only` is deprecated, please use `check-strategy=\"child\"` instead"), i.onChange !== void 0 && ie("cascader", "`on-change` is deprecated, please use `on-update:value` instead.");
+		});
+		let { mergedBorderedRef: m, mergedClsPrefixRef: h, namespaceRef: g, inlineThemeDisabled: y, mergedComponentPropsRef: pe } = ae(i), S = v("Cascader", "-cascader", me, de, i, h), { localeRef: C } = ce("Cascader"), he = t(i.defaultValue), w = d(r(() => i.value), he), T = r(() => i.leafOnly ? "child" : i.checkStrategy), E = t(""), D = se(i, { mergedSize: (e) => {
+			let { size: t } = i;
+			if (t) return t;
+			let { mergedSize: n } = e || {};
+			return n?.value ? n.value : pe?.value?.Cascader?.size || "medium";
+		} }), { mergedSizeRef: ge, mergedDisabledRef: _e, mergedStatusRef: ve } = D, O = t(null), k = t(null), A = t(null), j = t(null), M = t(null), N = t(/* @__PURE__ */ new Set()), ye = t(null), be = t(null), xe = p(i), P = t(!1), Se = (e) => {
+			N.value.add(e);
+		}, F = (e) => {
+			N.value.delete(e);
+		}, I = r(() => {
+			let { valueField: e, childrenField: t, disabledField: n } = i;
+			return ue(i.options, {
+				getDisabled(e) {
+					return e[n];
+				},
+				getKey(t) {
+					return t[e];
+				},
+				getChildren(e) {
+					return e[t];
+				}
+			});
+		}), L = r(() => {
+			let { cascade: e, multiple: t } = i;
+			return t && Array.isArray(w.value) ? I.value.getCheckedKeys(w.value, {
+				cascade: e,
+				allowNotLoaded: i.allowCheckingNotLoaded
+			}) : {
+				checkedKeys: [],
+				indeterminateKeys: []
+			};
+		}), R = r(() => L.value.checkedKeys), z = r(() => L.value.indeterminateKeys), Ce = r(() => {
+			let { treeNodePath: e, treeNode: t } = I.value.getPath(M.value), n;
+			return t === null ? n = [I.value.treeNodes] : (n = e.map((e) => e.siblings), !t.isLeaf && !N.value.has(t.key) && t.children && n.push(t.children)), n;
+		}), we = r(() => {
+			let { keyPath: e } = I.value.getPath(M.value);
+			return e;
+		}), B = r(() => S.value.self.optionHeight);
+		e(i.options) && c(i.options, (e, t) => {
+			e !== t && (M.value = null, j.value = null);
+		});
+		let V = t(!1);
+		function Te(e) {
+			let { onUpdateShow: t, "onUpdate:show": n } = i;
+			t && _(t, e), n && _(n, e), V.value = e;
+		}
+		function H(e, t, n) {
+			let { onUpdateValue: r, "onUpdate:value": a, onChange: o } = i, { nTriggerFormInput: s, nTriggerFormChange: c } = D;
+			r && _(r, e, t, n), a && _(a, e, t, n), o && _(o, e, t, n), he.value = e, s(), c();
+		}
+		function U(e) {
+			j.value = e;
+		}
+		function W(e) {
+			M.value = e;
+		}
+		function G(e) {
+			let { value: { getNode: t } } = I;
+			return e.map((e) => t(e)?.rawNode || null);
+		}
+		function Ee(e) {
+			let { cascade: t, multiple: n, filterable: r } = i, { value: { check: a, getNode: o, getPath: s } } = I;
+			if (n) try {
+				let { checkedKeys: n } = a(e, L.value.checkedKeys, {
+					cascade: t,
+					checkStrategy: T.value,
+					allowNotLoaded: i.allowCheckingNotLoaded
+				});
+				H(n, G(n), n.map((e) => x(s(e)?.treeNodePath))), r && Y(), j.value = e, M.value = e;
+			} catch (t) {
+				if (t instanceof le) {
+					if (O.value) {
+						let t = o(e);
+						t !== null && O.value.showErrorMessage(t.rawNode[i.labelField]);
+					}
+				} else throw t;
+			}
+			else if (T.value === "child") {
+				let t = o(e);
+				if (t?.isLeaf) H(e, t.rawNode, x(s(e).treeNodePath));
+				else return !1;
+			} else H(e, o(e)?.rawNode || null, x(s(e)?.treeNodePath));
+			return !0;
+		}
+		function K(e) {
+			let { cascade: t, multiple: n } = i;
+			if (n) {
+				let { value: { uncheck: n, getNode: r, getPath: a } } = I, { checkedKeys: o } = n(e, L.value.checkedKeys, {
+					cascade: t,
+					checkStrategy: T.value,
+					allowNotLoaded: i.allowCheckingNotLoaded
+				});
+				H(o, o.map((e) => r(e)?.rawNode || null), o.map((e) => x(a(e)?.treeNodePath))), j.value = e, M.value = e;
+			}
+		}
+		let De = r(() => {
+			if (i.multiple) {
+				let { showPath: e, separator: t, labelField: n, cascade: r } = i, { getCheckedKeys: a, getNode: o } = I.value;
+				return a(R.value, {
+					cascade: r,
+					checkStrategy: T.value,
+					allowNotLoaded: i.allowCheckingNotLoaded
+				}).checkedKeys.map((r) => {
+					let i = o(r);
+					return i === null ? {
+						label: String(r),
+						value: r
+					} : {
+						label: e ? b(i, t, n) : i.rawNode[n],
+						value: i.key
+					};
+				});
+			} else return [];
+		}), Oe = r(() => {
+			let { multiple: e, showPath: t, separator: n, labelField: r } = i, { value: a } = w;
+			if (!e && !Array.isArray(a)) {
+				let { getNode: e } = I.value;
+				if (a === null) return null;
+				let i = e(a);
+				return i === null ? {
+					label: String(a),
+					value: a
+				} : {
+					label: t ? b(i, n, r) : i.rawNode[r],
+					value: i.key
+				};
+			} else return null;
+		}), q = d(n(i, "show"), V), ke = r(() => {
+			let { placeholder: e } = i;
+			return e === void 0 ? C.value.placeholder : e;
+		}), J = r(() => !!(i.filterable && E.value));
+		c(q, (e) => {
+			if (!e || i.multiple) return;
+			let { value: t } = w;
+			!Array.isArray(t) && t !== null ? (j.value = t, M.value = t, o(() => {
+				var e;
+				if (!q.value) return;
+				let { value: t } = M;
+				if (w.value !== null) {
+					let n = I.value.getNode(t);
+					n && ((e = O.value) == null || e.scroll(n.level, n.index, u(B.value)));
+				}
+			})) : (j.value = null, M.value = null);
+		}, { immediate: !0 });
+		function Ae(e) {
+			let { onBlur: t } = i, { nTriggerFormBlur: n } = D;
+			t && _(t, e), n();
+		}
+		function je(e) {
+			let { onFocus: t } = i, { nTriggerFormFocus: n } = D;
+			t && _(t, e), n();
+		}
+		function Y() {
+			var e;
+			(e = A.value) == null || e.focusInput();
+		}
+		function Me() {
+			var e;
+			(e = A.value) == null || e.focus();
+		}
+		function X() {
+			_e.value || (E.value = "", Te(!0), i.filterable && Y());
+		}
+		function Z(e = !1) {
+			e && Me(), Te(!1), E.value = "";
+		}
+		function Ne(e) {
+			J.value || q.value && (A.value?.$el.contains(te(e)) || Z());
+		}
+		function Pe(e) {
+			J.value && Ne(e);
+		}
+		function Fe() {
+			i.clearFilterAfterSelect && (E.value = "");
+		}
+		function Q(e) {
+			var t, n, r;
+			let { value: a } = j, { value: o } = I;
+			switch (e) {
+				case "prev":
+					if (a !== null) {
+						let e = o.getPrev(a, { loop: !0 });
+						e !== null && (U(e.key), (t = O.value) == null || t.scroll(e.level, e.index, u(B.value)));
+					}
+					break;
+				case "next":
+					if (a === null) {
+						let e = o.getFirstAvailableNode();
+						e !== null && (U(e.key), (n = O.value) == null || n.scroll(e.level, e.index, u(B.value)));
+					} else {
+						let e = o.getNext(a, { loop: !0 });
+						e !== null && (U(e.key), (r = O.value) == null || r.scroll(e.level, e.index, u(B.value)));
+					}
+					break;
+				case "child":
+					if (a !== null) {
+						let e = o.getNode(a);
+						if (e !== null) if (e.shallowLoaded) {
+							let e = o.getChild(a);
+							e !== null && (W(a), U(e.key));
+						} else {
+							let { value: t } = N;
+							if (!t.has(a)) {
+								Se(a), W(a);
+								let { onLoad: t } = i;
+								t && t(e.rawNode).then(() => {
+									F(a);
+								}).catch(() => {
+									F(a);
+								});
+							}
+						}
+					}
+					break;
+				case "parent":
+					if (a !== null) {
+						let e = o.getParent(a);
+						if (e !== null) {
+							U(e.key);
+							let t = e.getParent();
+							W(t === null ? null : t.key);
+						}
+					}
+					break;
+			}
+		}
+		function Ie(e) {
+			var t, n;
+			switch (e.key) {
+				case " ":
+				case "ArrowDown":
+				case "ArrowUp":
+					if (i.filterable && q.value) break;
+					e.preventDefault();
+					break;
+			}
+			if (!l(e, "action")) switch (e.key) {
+				case " ": if (i.filterable) return;
+				case "Enter":
+					if (!q.value) X();
+					else {
+						let { value: e } = J, { value: t } = j;
+						if (e) k.value && k.value.enter() && Fe();
+						else if (t !== null) if (R.value.includes(t) || z.value.includes(t)) K(t);
+						else {
+							let e = Ee(t);
+							!i.multiple && e && Z(!0);
+						}
+					}
+					break;
+				case "ArrowUp":
+					e.preventDefault(), q.value && (J.value ? (t = k.value) == null || t.prev() : Q("prev"));
+					break;
+				case "ArrowDown":
+					e.preventDefault(), q.value ? J.value ? (n = k.value) == null || n.next() : Q("next") : X();
+					break;
+				case "ArrowLeft":
+					e.preventDefault(), q.value && !J.value && Q("parent");
+					break;
+				case "ArrowRight":
+					e.preventDefault(), q.value && !J.value && Q("child");
+					break;
+				case "Escape": q.value && (re(e), Z(!0));
+			}
+		}
+		function Le(e) {
+			Ie(e);
+		}
+		function Re(e) {
+			e.stopPropagation(), i.multiple ? H([], [], []) : H(null, null, null);
+		}
+		function ze(e) {
+			O.value?.$el.contains(e.relatedTarget) || (P.value = !0, je(e));
+		}
+		function Be(e) {
+			O.value?.$el.contains(e.relatedTarget) || (P.value = !1, Ae(e), Z());
+		}
+		function Ve(e) {
+			A.value?.$el.contains(e.relatedTarget) || (P.value = !0, je(e));
+		}
+		function He(e) {
+			A.value?.$el.contains(e.relatedTarget) || (P.value = !1, Ae(e));
+		}
+		function Ue(e) {
+			l(e, "action") || i.multiple && i.filter && (e.preventDefault(), Y());
+		}
+		function We() {
+			Z(!0);
+		}
+		function Ge() {
+			i.filterable ? X() : q.value ? Z(!0) : X();
+		}
+		function Ke(e) {
+			E.value = e.target.value;
+		}
+		function qe(e) {
+			let { multiple: t } = i, { value: n } = w;
+			t && Array.isArray(n) && e.value !== void 0 ? K(e.value) : H(null, null, null);
+		}
+		function Je() {
+			var e;
+			(e = ye.value) == null || e.syncPosition();
+		}
+		function Ye() {
+			var e;
+			(e = be.value) == null || e.syncPosition();
+		}
+		function Xe() {
+			q.value && (J.value ? Je() : Ye());
+		}
+		let $ = r(() => !!(i.multiple && i.cascade || T.value !== "child"));
+		s(fe, {
+			slots: a,
+			mergedClsPrefixRef: h,
+			mergedThemeRef: S,
+			mergedValueRef: w,
+			checkedKeysRef: R,
+			indeterminateKeysRef: z,
+			hoverKeyPathRef: we,
+			mergedCheckStrategyRef: T,
+			showCheckboxRef: $,
+			cascadeRef: n(i, "cascade"),
+			multipleRef: n(i, "multiple"),
+			keyboardKeyRef: j,
+			hoverKeyRef: M,
+			remoteRef: n(i, "remote"),
+			loadingKeySetRef: N,
+			expandTriggerRef: n(i, "expandTrigger"),
+			isMountedRef: f(),
+			onLoadRef: n(i, "onLoad"),
+			virtualScrollRef: n(i, "virtualScroll"),
+			optionHeightRef: B,
+			localeRef: C,
+			labelFieldRef: n(i, "labelField"),
+			renderLabelRef: n(i, "renderLabel"),
+			getColumnStyleRef: n(i, "getColumnStyle"),
+			renderPrefixRef: n(i, "renderPrefix"),
+			renderSuffixRef: n(i, "renderSuffix"),
+			spinPropsRef: n(i, "spinProps"),
+			syncCascaderMenuPosition: Ye,
+			syncSelectMenuPosition: Je,
+			updateKeyboardKey: U,
+			updateHoverKey: W,
+			addLoadingKey: Se,
+			deleteLoadingKey: F,
+			doCheck: Ee,
+			doUncheck: K,
+			closeMenu: Z,
+			handleSelectMenuClickOutside: Pe,
+			handleCascaderMenuClickOutside: Ne,
+			scrollbarPropsRef: n(i, "scrollbarProps"),
+			clearPattern: Fe
+		});
+		let Ze = {
+			focus: () => {
+				var e;
+				(e = A.value) == null || e.focus();
+			},
+			blur: () => {
+				var e;
+				(e = A.value) == null || e.blur();
+			},
+			getCheckedData: () => {
+				if ($.value) {
+					let e = R.value;
+					return {
+						keys: e,
+						options: G(e)
+					};
+				}
+				return {
+					keys: [],
+					options: []
+				};
+			},
+			getIndeterminateData: () => {
+				if ($.value) {
+					let e = z.value;
+					return {
+						keys: e,
+						options: G(e)
+					};
+				}
+				return {
+					keys: [],
+					options: []
+				};
+			}
+		}, Qe = r(() => {
+			let { self: { optionArrowColor: e, optionTextColor: t, optionTextColorActive: n, optionTextColorDisabled: r, optionCheckMarkColor: i, menuColor: a, menuBoxShadow: o, menuDividerColor: s, menuBorderRadius: c, menuHeight: ee, optionColorHover: l, optionHeight: te, optionFontSize: u, loadingColor: d, columnWidth: f }, common: { cubicBezierEaseInOut: p } } = S.value;
+			return {
+				"--n-bezier": p,
+				"--n-menu-border-radius": c,
+				"--n-menu-box-shadow": o,
+				"--n-menu-height": ee,
+				"--n-column-width": f,
+				"--n-menu-color": a,
+				"--n-menu-divider-color": s,
+				"--n-option-height": te,
+				"--n-option-font-size": u,
+				"--n-option-text-color": t,
+				"--n-option-text-color-disabled": r,
+				"--n-option-text-color-active": n,
+				"--n-option-color-hover": l,
+				"--n-option-check-mark-color": i,
+				"--n-option-arrow-color": e,
+				"--n-menu-mask-color": ne(a, { alpha: .75 }),
+				"--n-loading-color": d
+			};
+		}), $e = y ? oe("cascader", void 0, Qe, i) : void 0;
+		return Object.assign(Object.assign({}, Ze), {
+			handleTriggerResize: Xe,
+			mergedStatus: ve,
+			selectMenuFollowerRef: ye,
+			cascaderMenuFollowerRef: be,
+			triggerInstRef: A,
+			selectMenuInstRef: k,
+			cascaderMenuInstRef: O,
+			mergedBordered: m,
+			mergedClsPrefix: h,
+			namespace: g,
+			mergedValue: w,
+			mergedShow: q,
+			showSelectMenu: J,
+			pattern: E,
+			treeMate: I,
+			mergedSize: ge,
+			mergedDisabled: _e,
+			localizedPlaceholder: ke,
+			selectedOption: Oe,
+			selectedOptions: De,
+			adjustedTo: xe,
+			menuModel: Ce,
+			handleMenuTabout: We,
+			handleMenuFocus: Ve,
+			handleMenuBlur: He,
+			handleMenuKeydown: Le,
+			handleMenuMousedown: Ue,
+			handleTriggerFocus: ze,
+			handleTriggerBlur: Be,
+			handleTriggerClick: Ge,
+			handleClear: Re,
+			handleDeleteOption: qe,
+			handlePatternInput: Ke,
+			handleKeydown: Ie,
+			focused: P,
+			optionHeight: B,
+			mergedTheme: S,
+			cssVars: y ? void 0 : Qe,
+			themeClass: $e?.themeClass,
+			onRender: $e?.onRender
+		});
+	},
+	render() {
+		let { mergedClsPrefix: e } = this;
+		return a("div", { class: `${e}-cascader` }, a(m, null, { default: () => [
+			a(h, null, { default: () => a(y, {
+				onResize: this.handleTriggerResize,
+				ref: "triggerInstRef",
+				status: this.mergedStatus,
+				clsPrefix: e,
+				maxTagCount: this.maxTagCount,
+				ellipsisTagPopoverProps: this.ellipsisTagPopoverProps,
+				bordered: this.mergedBordered,
+				size: this.mergedSize,
+				theme: this.mergedTheme.peers.InternalSelection,
+				themeOverrides: this.mergedTheme.peerOverrides.InternalSelection,
+				active: this.mergedShow,
+				pattern: this.pattern,
+				placeholder: this.localizedPlaceholder,
+				selectedOption: this.selectedOption,
+				selectedOptions: this.selectedOptions,
+				multiple: this.multiple,
+				filterable: this.filterable,
+				clearable: this.clearable,
+				disabled: this.mergedDisabled,
+				focused: this.focused,
+				onFocus: this.handleTriggerFocus,
+				onBlur: this.handleTriggerBlur,
+				onClick: this.handleTriggerClick,
+				onClear: this.handleClear,
+				onDeleteOption: this.handleDeleteOption,
+				onPatternInput: this.handlePatternInput,
+				onKeydown: this.handleKeydown
+			}, { arrow: () => {
+				var e;
+				return (e = this.$slots).arrow?.call(e);
+			} }) }),
+			a(g, {
+				key: "cascaderMenu",
+				ref: "cascaderMenuFollowerRef",
+				show: this.mergedShow && !this.showSelectMenu,
+				containerClass: this.namespace,
+				placement: this.placement,
+				width: this.options.length ? void 0 : "target",
+				teleportDisabled: this.adjustedTo === p.tdkey,
+				to: this.adjustedTo
+			}, { default: () => {
+				var e;
+				(e = this.onRender) == null || e.call(this);
+				let { menuProps: t } = this;
+				return a(pe, Object.assign({}, t, {
+					ref: "cascaderMenuInstRef",
+					class: [this.themeClass, t?.class],
+					value: this.mergedValue,
+					show: this.mergedShow && !this.showSelectMenu,
+					menuModel: this.menuModel,
+					style: [this.cssVars, t?.style],
+					onFocus: this.handleMenuFocus,
+					onBlur: this.handleMenuBlur,
+					onKeydown: this.handleMenuKeydown,
+					onMousedown: this.handleMenuMousedown,
+					onTabout: this.handleMenuTabout
+				}), {
+					action: () => {
+						var e;
+						return (e = this.$slots).action?.call(e);
+					},
+					empty: () => {
+						var e;
+						return (e = this.$slots).empty?.call(e);
+					}
+				});
+			} }),
+			a(g, {
+				key: "selectMenu",
+				ref: "selectMenuFollowerRef",
+				show: this.mergedShow && this.showSelectMenu,
+				containerClass: this.namespace,
+				width: "target",
+				placement: this.placement,
+				to: this.adjustedTo,
+				teleportDisabled: this.adjustedTo === p.tdkey
+			}, { default: () => {
+				var e;
+				(e = this.onRender) == null || e.call(this);
+				let { filterMenuProps: t } = this;
+				return a(S, Object.assign({}, t, {
+					ref: "selectMenuInstRef",
+					class: [this.themeClass, t?.class],
+					value: this.mergedValue,
+					show: this.mergedShow && this.showSelectMenu,
+					pattern: this.pattern,
+					multiple: this.multiple,
+					tmNodes: this.treeMate.treeNodes,
+					filter: this.filter,
+					labelField: this.labelField,
+					separator: this.separator,
+					style: [this.cssVars, t?.style]
+				}));
+			} })
+		] }));
+	}
+});
+//#endregion
+export { C as default };