@v-c/tree-select 0.0.1

package/dist/TreeSelect.cjs

@@ -0,0 +1,953 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_rolldown_runtime = require("./_virtual/rolldown_runtime.cjs");
+const require_LegacyContext = require("./LegacyContext.cjs");
+const require_TreeSelectContext = require("./TreeSelectContext.cjs");
+const require_valueUtil = require("./utils/valueUtil.cjs");
+const require_OptionList = require("./OptionList.cjs");
+const require_useCache = require("./hooks/useCache.cjs");
+const require_useCheckedKeys = require("./hooks/useCheckedKeys.cjs");
+const require_useDataEntities = require("./hooks/useDataEntities.cjs");
+const require_legacyUtil = require("./utils/legacyUtil.cjs");
+const require_useFilterTreeData = require("./hooks/useFilterTreeData.cjs");
+const require_useRefFunc = require("./hooks/useRefFunc.cjs");
+const require_useSearchConfig = require("./hooks/useSearchConfig.cjs");
+const require_useTreeData = require("./hooks/useTreeData.cjs");
+const require_strategyUtil = require("./utils/strategyUtil.cjs");
+const require_warningPropsUtil = require("./utils/warningPropsUtil.cjs");
+let vue = require("vue");
+let _v_c_select = require("@v-c/select");
+let _v_c_tree = require("@v-c/tree");
+let _v_c_util = require("@v-c/util");
+let _v_c_util_dist_props_util = require("@v-c/util/dist/props-util");
+function isRawValue(value) {
+	return !value || typeof value !== "object";
+}
+var defaults = {
+	prefixCls: "vc-tree-select",
+	listHeight: 200,
+	listItemHeight: 20,
+	listItemScrollOffset: 0,
+	popupMatchSelectWidth: true
+};
+var omitKeyList = [
+	"id",
+	"prefixCls",
+	"value",
+	"defaultValue",
+	"onChange",
+	"showSearch",
+	"searchValue",
+	"inputValue",
+	"onSearch",
+	"autoClearSearchValue",
+	"filterTreeNode",
+	"treeNodeFilterProp",
+	"onSelect",
+	"onDeselect",
+	"showCheckedStrategy",
+	"treeNodeLabelProp",
+	"fieldNames",
+	"multiple",
+	"treeCheckable",
+	"treeCheckStrictly",
+	"labelInValue",
+	"maxCount",
+	"treeData",
+	"treeDataSimpleMode",
+	"treeDefaultExpandAll",
+	"treeExpandedKeys",
+	"treeDefaultExpandedKeys",
+	"onTreeExpand",
+	"treeExpandAction",
+	"virtual",
+	"listHeight",
+	"listItemHeight",
+	"listItemScrollOffset",
+	"onPopupVisibleChange",
+	"popupMatchSelectWidth",
+	"treeTitleRender",
+	"treeLine",
+	"treeIcon",
+	"showTreeIcon",
+	"switcherIcon",
+	"treeMotion",
+	"treeLoadedKeys",
+	"onTreeLoad",
+	"loadData",
+	"onPopupScroll",
+	"classNames",
+	"styles"
+];
+var TreeSelect = /* @__PURE__ */ (0, vue.defineComponent)({
+	props: /* @__PURE__ */ (0, vue.mergeDefaults)({
+		prefixCls: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		id: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		classNames: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		styles: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		value: {
+			required: false,
+			default: void 0
+		},
+		defaultValue: {
+			required: false,
+			default: void 0
+		},
+		onChange: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		showSearch: {
+			type: [Boolean, Object],
+			required: false,
+			default: void 0
+		},
+		searchValue: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		inputValue: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		onSearch: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		autoClearSearchValue: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		filterTreeNode: {
+			type: [Boolean, Function],
+			required: false,
+			default: void 0
+		},
+		treeNodeFilterProp: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		onSelect: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onDeselect: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		showCheckedStrategy: {
+			required: false,
+			default: void 0
+		},
+		treeNodeLabelProp: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		fieldNames: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		multiple: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		treeCheckable: {
+			type: [
+				Boolean,
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		treeCheckStrictly: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		labelInValue: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		maxCount: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		treeData: {
+			type: Array,
+			required: false,
+			default: void 0
+		},
+		treeDataSimpleMode: {
+			type: [Boolean, Object],
+			required: false,
+			default: void 0
+		},
+		loadData: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		treeLoadedKeys: {
+			type: Array,
+			required: false,
+			default: void 0
+		},
+		onTreeLoad: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		treeDefaultExpandAll: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		treeExpandedKeys: {
+			type: Array,
+			required: false,
+			default: void 0
+		},
+		treeDefaultExpandedKeys: {
+			type: Array,
+			required: false,
+			default: void 0
+		},
+		onTreeExpand: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		treeExpandAction: {
+			type: [Boolean, String],
+			required: false,
+			default: void 0
+		},
+		virtual: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		listHeight: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		listItemHeight: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		listItemScrollOffset: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		onPopupVisibleChange: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		treeTitleRender: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		treeLine: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		treeIcon: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		showTreeIcon: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		switcherIcon: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		treeMotion: {
+			required: false,
+			default: void 0
+		},
+		onPopupScroll: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		popupMatchSelectWidth: {
+			type: [Boolean, Number],
+			required: false,
+			default: void 0
+		},
+		className: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		style: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		tagRender: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		direction: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		autoFocus: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		placeholder: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		title: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		tabIndex: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		notFoundContent: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		onClear: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		maxLength: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		showScrollBar: {
+			type: [Boolean, String],
+			required: false,
+			default: void 0
+		},
+		choiceTransitionName: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		disabled: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		loading: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		defaultOpen: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		getInputElement: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		getRawInputElement: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		maxTagTextLength: {
+			type: Number,
+			required: false,
+			default: void 0
+		},
+		maxTagCount: {
+			type: [Number, String],
+			required: false,
+			default: void 0
+		},
+		maxTagPlaceholder: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		tokenSeparators: {
+			type: Array,
+			required: false,
+			default: void 0
+		},
+		allowClear: {
+			type: [Boolean, Object],
+			required: false,
+			default: void 0
+		},
+		prefix: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		suffixIcon: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		suffix: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		clearIcon: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		removeIcon: {
+			type: [
+				Object,
+				Function,
+				String,
+				Number,
+				null,
+				Boolean,
+				Array
+			],
+			required: false,
+			default: void 0
+		},
+		animation: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		transitionName: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		popupStyle: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		popupClassName: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		popupRender: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		popupAlign: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		placement: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		builtinPlacements: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		getPopupContainer: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		showAction: {
+			type: Array,
+			required: false,
+			default: void 0
+		},
+		onBlur: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onFocus: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onKeyUp: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onKeyDown: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseDown: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onInputKeyDown: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseEnter: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onMouseLeave: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		onClick: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		components: {
+			type: Object,
+			required: false,
+			default: void 0
+		}
+	}, defaults),
+	name: "TreeSelect",
+	inheritAttrs: false,
+	setup(props, { attrs, expose, slots }) {
+		const baseSelectRef = (0, vue.shallowRef)(null);
+		expose({
+			focus: () => baseSelectRef.value?.focus(),
+			blur: () => baseSelectRef.value?.blur(),
+			scrollTo: (arg) => baseSelectRef.value?.scrollTo?.(arg)
+		});
+		const mergedId = (0, _v_c_util.useId)(props.id);
+		const treeConduction = (0, vue.computed)(() => !!props.treeCheckable && !props.treeCheckStrictly);
+		const mergedCheckable = (0, vue.computed)(() => props.treeCheckable || props.treeCheckStrictly);
+		const mergedLabelInValue = (0, vue.computed)(() => !!props.treeCheckStrictly || !!props.labelInValue);
+		const mergedMultiple = (0, vue.computed)(() => !!mergedCheckable.value || !!props.multiple);
+		const searchProps = (0, vue.computed)(() => ({
+			searchValue: props.searchValue,
+			inputValue: props.inputValue,
+			onSearch: props.onSearch,
+			autoClearSearchValue: props.autoClearSearchValue,
+			filterTreeNode: props.filterTreeNode,
+			treeNodeFilterProp: props.treeNodeFilterProp
+		}));
+		const [mergedShowSearch, searchConfig] = require_useSearchConfig.default((0, vue.computed)(() => props.showSearch), searchProps);
+		const mergedTreeNodeFilterProp = (0, vue.computed)(() => searchConfig.value.treeNodeFilterProp || "value");
+		const mergedAutoClearSearchValue = (0, vue.computed)(() => searchConfig.value.autoClearSearchValue !== false);
+		const internalValue = (0, vue.shallowRef)(props?.value ?? props?.defaultValue);
+		(0, vue.watch)(() => props.value, () => {
+			internalValue.value = props?.value;
+		});
+		const setInternalValue = (val) => {
+			internalValue.value = val;
+		};
+		const mergedShowCheckedStrategy = (0, vue.computed)(() => {
+			if (!props.treeCheckable) return require_strategyUtil.SHOW_ALL;
+			return props.showCheckedStrategy || "SHOW_CHILD";
+		});
+		if (process.env.NODE_ENV !== "production") require_warningPropsUtil.default(props);
+		const mergedFieldNames = (0, vue.computed)(() => require_valueUtil.fillFieldNames(props.fieldNames));
+		const [internalSearchValue, setSearchValue] = (0, _v_c_util.useMergedState)(() => "", { value: (0, vue.computed)(() => searchConfig.value.searchValue) });
+		const mergedSearchValue = (0, vue.computed)(() => internalSearchValue.value || "");
+		const onInternalSearch = (searchText) => {
+			setSearchValue(searchText);
+			searchConfig.value.onSearch?.(searchText);
+		};
+		const slotTreeData = (0, vue.shallowRef)([]);
+		const slotTreeDataSignature = (0, vue.shallowRef)("");
+		const mergedSourceTreeData = (0, vue.computed)(() => {
+			if (props.treeData !== void 0) return props.treeData;
+			return slotTreeData.value;
+		});
+		const getTreeDataSignature = (data) => {
+			const dig = (list) => {
+				return (list || []).map((node) => {
+					const key = String(node?.key);
+					const children = node?.children;
+					return `${key}{${children?.length ? dig(children) : ""}}`;
+				}).join("|");
+			};
+			return dig(data);
+		};
+		const mergedTreeData = require_useTreeData.default(mergedSourceTreeData, (0, vue.computed)(() => props.treeDataSimpleMode));
+		const { keyEntities, valueEntities } = require_useDataEntities.default(mergedTreeData, mergedFieldNames);
+		const splitRawValues = (newRawValues) => {
+			const missingRawValues = [];
+			const existRawValues = [];
+			newRawValues.forEach((val) => {
+				if (valueEntities.value.has(val)) existRawValues.push(val);
+				else missingRawValues.push(val);
+			});
+			return {
+				missingRawValues,
+				existRawValues
+			};
+		};
+		const filteredTreeData = require_useFilterTreeData.default(mergedTreeData, mergedSearchValue, {
+			fieldNames: mergedFieldNames,
+			treeNodeFilterProp: mergedTreeNodeFilterProp,
+			filterTreeNode: (0, vue.computed)(() => searchConfig.value.filterTreeNode)
+		});
+		const getLabel = (item) => {
+			if (!item) return;
+			if (props.treeNodeLabelProp) return item[props.treeNodeLabelProp];
+			const titleList = mergedFieldNames.value._title;
+			for (let i = 0; i < titleList.length; i += 1) {
+				const title = item[titleList[i]];
+				if (title !== void 0) return title;
+			}
+		};
+		const toLabeledValues = (draftValues) => {
+			return require_valueUtil.toArray(draftValues).map((val) => {
+				if (isRawValue(val)) return { value: val };
+				return val;
+			});
+		};
+		const renderTreeTitleRender = (node) => {
+			let label;
+			const labelInfo = props?.treeTitleRender?.(node);
+			if (typeof labelInfo === "string" || typeof labelInfo === "number") label = labelInfo;
+			else {
+				const labelArr = (0, _v_c_util_dist_props_util.filterEmpty)(Array.isArray(labelInfo) ? labelInfo : [labelInfo]);
+				if (labelArr.length) label = labelArr.length === 1 ? labelArr[0] : labelArr;
+			}
+			return label;
+		};
+		const convert2LabelValues = (draftValues) => {
+			return toLabeledValues(draftValues).map((item) => {
+				let { label: rawLabel } = item;
+				const { value: rawValue, halfChecked: rawHalfChecked } = item;
+				let rawDisabled;
+				const entity = valueEntities.value.get(rawValue);
+				if (entity) {
+					rawLabel = props.treeTitleRender ? renderTreeTitleRender(entity.node) : rawLabel ?? getLabel(entity.node);
+					rawDisabled = entity.node.disabled;
+				} else if (rawLabel === void 0) rawLabel = toLabeledValues(internalValue.value).find((labeledItem) => labeledItem.value === rawValue)?.label;
+				return {
+					label: rawLabel,
+					value: rawValue,
+					halfChecked: rawHalfChecked,
+					disabled: rawDisabled
+				};
+			});
+		};
+		const rawMixedLabeledValues = (0, vue.computed)(() => toLabeledValues(internalValue.value === null ? [] : internalValue.value));
+		const rawLabeledValues = (0, vue.computed)(() => rawMixedLabeledValues.value.filter((item) => !item.halfChecked));
+		const rawHalfLabeledValues = (0, vue.computed)(() => rawMixedLabeledValues.value.filter((item) => !!item.halfChecked));
+		const rawValues = (0, vue.computed)(() => rawLabeledValues.value.map((item) => item.value));
+		const [rawCheckedValues, rawHalfCheckedValues] = require_useCheckedKeys.default(rawLabeledValues, rawHalfLabeledValues, treeConduction, keyEntities);
+		const [cachedDisplayValues] = require_useCache.default((0, vue.computed)(() => {
+			const rawDisplayValues = convert2LabelValues(require_strategyUtil.formatStrategyValues(rawCheckedValues.value, mergedShowCheckedStrategy.value, keyEntities.value, mergedFieldNames.value).map((key) => keyEntities.value[String(key)]?.node?.[mergedFieldNames.value.value] ?? key).map((val) => {
+				const targetItem = rawLabeledValues.value.find((item) => item.value === val);
+				let label;
+				if (props.labelInValue) label = targetItem?.label;
+				else label = renderTreeTitleRender(targetItem);
+				return {
+					value: val,
+					label
+				};
+			}));
+			const firstVal = rawDisplayValues[0];
+			if (!mergedMultiple.value && firstVal && require_valueUtil.isNil(firstVal.value) && require_valueUtil.isNil(firstVal.label)) return [];
+			return rawDisplayValues.map((item) => ({
+				...item,
+				label: item.label ?? item.value
+			}));
+		}));
+		const mergedMaxCount = (0, vue.computed)(() => {
+			if (mergedMultiple.value && (mergedShowCheckedStrategy.value === "SHOW_CHILD" || props.treeCheckStrictly || !props.treeCheckable)) return props.maxCount;
+			return null;
+		});
+		const triggerChange = require_useRefFunc.default((newRawValues, extra, source) => {
+			const formattedKeyList = require_strategyUtil.formatStrategyValues(newRawValues, mergedShowCheckedStrategy.value, keyEntities.value, mergedFieldNames.value);
+			if (mergedMaxCount.value && formattedKeyList.length > mergedMaxCount.value) return;
+			setInternalValue(convert2LabelValues(newRawValues));
+			if (mergedAutoClearSearchValue.value) setSearchValue("");
+			if (props.onChange) {
+				let eventValues = newRawValues;
+				if (treeConduction.value) eventValues = formattedKeyList.map((key) => {
+					const entity = valueEntities.value.get(key);
+					return entity ? entity.node[mergedFieldNames.value.value] : key;
+				});
+				const { triggerValue, selected } = extra || {
+					triggerValue: void 0,
+					selected: void 0
+				};
+				let returnRawValues = eventValues;
+				if (props.treeCheckStrictly) {
+					const halfValues = rawHalfLabeledValues.value.filter((item) => !eventValues.includes(item.value));
+					returnRawValues = [...returnRawValues, ...halfValues];
+				}
+				const returnLabeledValues = convert2LabelValues(returnRawValues);
+				const additionalInfo = {
+					preValue: rawLabeledValues.value,
+					triggerValue
+				};
+				let showPosition = true;
+				if (props.treeCheckStrictly || source === "selection" && !selected) showPosition = false;
+				require_legacyUtil.fillAdditionalInfo(additionalInfo, triggerValue, newRawValues, mergedTreeData.value, showPosition, mergedFieldNames.value);
+				if (mergedCheckable.value) additionalInfo.checked = selected;
+				else additionalInfo.selected = selected;
+				const returnValues = mergedLabelInValue.value ? returnLabeledValues : returnLabeledValues.map((item) => item.value);
+				props.onChange(mergedMultiple.value ? returnValues : returnValues[0], mergedLabelInValue.value ? null : returnLabeledValues.map((item) => item.label), additionalInfo);
+			}
+		});
+		const onOptionSelect = (selectedKey, { selected, source }) => {
+			const node = keyEntities.value[String(selectedKey)]?.node;
+			const selectedValue = node?.[mergedFieldNames.value.value] ?? selectedKey;
+			if (!mergedMultiple.value) triggerChange([selectedValue], {
+				selected: true,
+				triggerValue: selectedValue
+			}, "option");
+			else {
+				let newRawValues = selected ? [...rawValues.value, selectedValue] : rawCheckedValues.value.filter((v) => v !== selectedValue);
+				if (treeConduction.value) {
+					const { missingRawValues, existRawValues } = splitRawValues(newRawValues);
+					const keyList = existRawValues.map((val) => {
+						const entity = valueEntities.value.get(val);
+						return entity ? entity.key : val;
+					});
+					let checkedKeys;
+					if (selected) ({checkedKeys} = (0, _v_c_tree.conductCheck)(keyList, true, keyEntities.value));
+					else ({checkedKeys} = (0, _v_c_tree.conductCheck)(keyList, {
+						checked: false,
+						halfCheckedKeys: rawHalfCheckedValues.value
+					}, keyEntities.value));
+					newRawValues = [...missingRawValues, ...checkedKeys.map((key) => keyEntities.value[String(key)].node[mergedFieldNames.value.value])];
+				}
+				triggerChange(newRawValues, {
+					selected,
+					triggerValue: selectedValue
+				}, source || "option");
+			}
+			if (selected || !mergedMultiple.value) props.onSelect?.(selectedValue, require_legacyUtil.fillLegacyProps(node));
+			else props.onDeselect?.(selectedValue, require_legacyUtil.fillLegacyProps(node));
+		};
+		const onInternalPopupVisibleChange = (open) => {
+			props.onPopupVisibleChange?.(open);
+		};
+		const onDisplayValuesChange = require_useRefFunc.default((newValues, info) => {
+			const newRawValues = newValues.map((item) => item.value);
+			if (info.type === "clear") {
+				triggerChange(newRawValues, {}, "selection");
+				return;
+			}
+			if (info.values.length) onOptionSelect(info.values[0].value, {
+				selected: false,
+				source: "selection"
+			});
+		});
+		require_TreeSelectContext.useTreeSelectProvider((0, vue.computed)(() => {
+			return {
+				virtual: props.virtual,
+				popupMatchSelectWidth: props.popupMatchSelectWidth ?? defaults.popupMatchSelectWidth,
+				listHeight: props.listHeight ?? defaults.listHeight,
+				listItemHeight: props.listItemHeight ?? defaults.listItemHeight,
+				listItemScrollOffset: props.listItemScrollOffset ?? defaults.listItemScrollOffset,
+				treeData: filteredTreeData.value,
+				fieldNames: mergedFieldNames.value,
+				onSelect: onOptionSelect,
+				treeExpandAction: props.treeExpandAction,
+				treeTitleRender: props.treeTitleRender,
+				onPopupScroll: props.onPopupScroll,
+				leftMaxCount: props.maxCount === void 0 ? null : props.maxCount - cachedDisplayValues.value.length,
+				leafCountOnly: mergedShowCheckedStrategy.value === "SHOW_CHILD" && !props.treeCheckStrictly && !!props.treeCheckable,
+				valueEntities: valueEntities.value,
+				classNames: props.classNames,
+				styles: props.styles
+			};
+		}));
+		require_LegacyContext.useLegacyProvider((0, vue.computed)(() => ({
+			checkable: mergedCheckable.value,
+			loadData: props.loadData,
+			treeLoadedKeys: props.treeLoadedKeys,
+			onTreeLoad: props.onTreeLoad,
+			checkedKeys: rawCheckedValues.value,
+			halfCheckedKeys: rawHalfCheckedValues.value,
+			treeDefaultExpandAll: props.treeDefaultExpandAll,
+			treeExpandedKeys: props.treeExpandedKeys,
+			treeDefaultExpandedKeys: props.treeDefaultExpandedKeys || [],
+			onTreeExpand: props.onTreeExpand,
+			treeIcon: props.treeIcon,
+			treeMotion: props.treeMotion,
+			showTreeIcon: props.showTreeIcon,
+			switcherIcon: props.switcherIcon,
+			treeLine: props.treeLine,
+			treeNodeFilterProp: mergedTreeNodeFilterProp.value,
+			keyEntities: keyEntities.value
+		})));
+		return () => {
+			if (props.treeData === void 0) {
+				const parsed = require_legacyUtil.convertChildrenToData(slots.default?.() ?? []);
+				const signature = getTreeDataSignature(parsed);
+				if (signature !== slotTreeDataSignature.value) {
+					slotTreeDataSignature.value = signature;
+					slotTreeData.value = parsed;
+				}
+			}
+			return (0, vue.createVNode)(_v_c_select.BaseSelect, (0, vue.mergeProps)({ ...attrs }, (0, _v_c_util.omit)(props, omitKeyList), {
+				"ref": (el) => {
+					baseSelectRef.value = el;
+				},
+				"id": mergedId,
+				"prefixCls": props.prefixCls || defaults.prefixCls,
+				"mode": mergedMultiple.value ? "multiple" : void 0,
+				"classNames": props.classNames,
+				"styles": props.styles,
+				"displayValues": cachedDisplayValues.value,
+				"onDisplayValuesChange": onDisplayValuesChange,
+				"autoClearSearchValue": mergedAutoClearSearchValue.value,
+				"showSearch": mergedShowSearch.value,
+				"searchValue": mergedSearchValue.value,
+				"onSearch": (v) => {
+					onInternalSearch(v);
+				},
+				"OptionList": require_OptionList.default,
+				"emptyOptions": !mergedTreeData.value.length,
+				"onPopupVisibleChange": onInternalPopupVisibleChange,
+				"popupMatchSelectWidth": props.popupMatchSelectWidth ?? defaults.popupMatchSelectWidth
+			}), null);
+		};
+	}
+});
+var TreeSelect_default = TreeSelect;
+exports.default = TreeSelect_default;