@v-c/select 0.0.1

package/dist/hooks/useBaseProps.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+var BaseSelectContext = Symbol("BaseSelectContext");
+function useBaseSelectProvider(context) {
+	(0, vue.provide)(BaseSelectContext, context);
+}
+function useBaseProps() {
+	return (0, vue.inject)(BaseSelectContext, (0, vue.ref)(null));
+}
+exports.default = useBaseProps;
+exports.useBaseSelectProvider = useBaseSelectProvider;

package/dist/hooks/useBaseProps.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { BaseSelectProps } from '../BaseSelect';
+export interface BaseSelectContextProps extends BaseSelectProps {
+    triggerOpen: boolean;
+    multiple: boolean;
+    toggleOpen: (open?: boolean) => void;
+    role?: string;
+}
+export declare function useBaseSelectProvider(context: Ref<BaseSelectContextProps>): void;
+export default function useBaseProps(): Ref<BaseSelectContextProps | null>;

package/dist/hooks/useBaseProps.js

@@ -0,0 +1,9 @@
+import { inject, provide, ref } from "vue";
+var BaseSelectContext = Symbol("BaseSelectContext");
+function useBaseSelectProvider(context) {
+	provide(BaseSelectContext, context);
+}
+function useBaseProps() {
+	return inject(BaseSelectContext, ref(null));
+}
+export { useBaseProps as default, useBaseSelectProvider };

package/dist/hooks/useCache.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useCache(labeledValues, valueOptions) {
+	const cacheRef = (0, vue.shallowRef)({
+		values: /* @__PURE__ */ new Map(),
+		options: /* @__PURE__ */ new Map()
+	});
+	const filledLabeledValues = (0, vue.computed)(() => {
+		const { values: prevValueCache, options: prevOptionCache } = cacheRef.value;
+		const patchedValues = labeledValues.value.map((item) => {
+			if (item.label === void 0) return {
+				...item,
+				label: prevValueCache.get(item.value)?.label
+			};
+			return item;
+		});
+		const valueCache = /* @__PURE__ */ new Map();
+		const optionCache = /* @__PURE__ */ new Map();
+		patchedValues.forEach((item) => {
+			valueCache.set(item.value, item);
+			const option = valueOptions.value.get(item.value) || prevOptionCache.get(item.value);
+			if (option) optionCache.set(item.value, option);
+		});
+		cacheRef.value = {
+			values: valueCache,
+			options: optionCache
+		};
+		return patchedValues;
+	});
+	const getOption = (val) => {
+		return valueOptions.value.get(val) || cacheRef.value.options.get(val);
+	};
+	return [filledLabeledValues, getOption];
+}
+exports.default = useCache;

package/dist/hooks/useCache.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { RawValueType } from '../interface';
+import { DefaultOptionType, LabelInValueType } from '../Select';
+/**
+ * Cache `value` related LabeledValue & options.
+ */
+export default function useCache(labeledValues: Ref<LabelInValueType[]>, valueOptions: Ref<Map<RawValueType, DefaultOptionType>>): [Ref<LabelInValueType[]>, (val: RawValueType) => DefaultOptionType | undefined];

package/dist/hooks/useCache.js

@@ -0,0 +1,34 @@
+import { computed, shallowRef } from "vue";
+function useCache(labeledValues, valueOptions) {
+	const cacheRef = shallowRef({
+		values: /* @__PURE__ */ new Map(),
+		options: /* @__PURE__ */ new Map()
+	});
+	const filledLabeledValues = computed(() => {
+		const { values: prevValueCache, options: prevOptionCache } = cacheRef.value;
+		const patchedValues = labeledValues.value.map((item) => {
+			if (item.label === void 0) return {
+				...item,
+				label: prevValueCache.get(item.value)?.label
+			};
+			return item;
+		});
+		const valueCache = /* @__PURE__ */ new Map();
+		const optionCache = /* @__PURE__ */ new Map();
+		patchedValues.forEach((item) => {
+			valueCache.set(item.value, item);
+			const option = valueOptions.value.get(item.value) || prevOptionCache.get(item.value);
+			if (option) optionCache.set(item.value, option);
+		});
+		cacheRef.value = {
+			values: valueCache,
+			options: optionCache
+		};
+		return patchedValues;
+	});
+	const getOption = (val) => {
+		return valueOptions.value.get(val) || cacheRef.value.options.get(val);
+	};
+	return [filledLabeledValues, getOption];
+}
+export { useCache as default };

package/dist/hooks/useComponents.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useComponents(components, getInputElement, getRawInputElement) {
+	return (0, vue.computed)(() => {
+		let { root, input } = components.value || {};
+		if (getRawInputElement?.value) root = getRawInputElement.value?.();
+		if (getInputElement?.value) input = getInputElement.value?.();
+		return {
+			root,
+			input
+		};
+	});
+}
+exports.default = useComponents;

package/dist/hooks/useComponents.d.ts

@@ -0,0 +1,8 @@
+import { VueNode } from '@v-c/util/dist/type';
+import { Ref } from 'vue';
+import { BaseSelectProps } from '../BaseSelect';
+export interface ComponentsConfig {
+    root?: VueNode | string | any;
+    input?: VueNode | string | any;
+}
+export default function useComponents(components: Ref<ComponentsConfig>, getInputElement?: Ref<BaseSelectProps['getInputElement']>, getRawInputElement?: Ref<BaseSelectProps['getRawInputElement']>): Ref<ComponentsConfig>;

package/dist/hooks/useComponents.js

@@ -0,0 +1,13 @@
+import { computed } from "vue";
+function useComponents(components, getInputElement, getRawInputElement) {
+	return computed(() => {
+		let { root, input } = components.value || {};
+		if (getRawInputElement?.value) root = getRawInputElement.value?.();
+		if (getInputElement?.value) input = getInputElement.value?.();
+		return {
+			root,
+			input
+		};
+	});
+}
+export { useComponents as default };

package/dist/hooks/useFilterOptions.cjs

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+const require_commonUtil = require("../utils/commonUtil.cjs");
+let vue = require("vue");
+function includes(test, search) {
+	return require_commonUtil.toArray(test).join("").toUpperCase().includes(search);
+}
+function useFilterOptions(options, fieldNames, searchValue, filterOption, optionFilterProp) {
+	return (0, vue.computed)(() => {
+		if (!searchValue.value || filterOption.value === false) return options.value;
+		const { options: fieldOptions, label: fieldLabel, value: fieldValue } = fieldNames.value;
+		const filteredOptions = [];
+		const customizeFilter = typeof filterOption.value === "function";
+		const upperSearch = searchValue.value.toUpperCase();
+		const defaultFilter = (_, option) => {
+			if (optionFilterProp.value && option) return includes(option[optionFilterProp.value], upperSearch);
+			if (option && option[fieldOptions]) return includes(option[fieldLabel !== "children" ? fieldLabel : "label"], upperSearch);
+			return option ? includes(option[fieldValue], upperSearch) : false;
+		};
+		const filterFunc = customizeFilter ? filterOption.value : defaultFilter;
+		const wrapOption = customizeFilter ? (opt) => require_commonUtil.injectPropsWithOption(opt) : (opt) => opt;
+		options.value.forEach((item) => {
+			if (item[fieldOptions]) {
+				if (filterFunc(searchValue.value, wrapOption(item))) filteredOptions.push(item);
+				else {
+					const subOptions = item[fieldOptions].filter((subItem) => filterFunc(searchValue.value, wrapOption(subItem)));
+					if (subOptions.length) filteredOptions.push({
+						...item,
+						[fieldOptions]: subOptions
+					});
+				}
+				return;
+			}
+			if (filterFunc(searchValue.value, wrapOption(item))) filteredOptions.push(item);
+		});
+		return filteredOptions;
+	});
+}
+exports.default = useFilterOptions;

package/dist/hooks/useFilterOptions.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+import { DefaultOptionType, FieldNames, SelectProps } from '../Select';
+export default function useFilterOptions(options: Ref<DefaultOptionType[]>, fieldNames: Ref<FieldNames>, searchValue: Ref<string | undefined>, filterOption: Ref<SelectProps['filterOption']>, optionFilterProp: Ref<string | undefined>): import('vue').ComputedRef<DefaultOptionType[]>;

package/dist/hooks/useFilterOptions.js

@@ -0,0 +1,37 @@
+import { injectPropsWithOption, toArray } from "../utils/commonUtil.js";
+import { computed } from "vue";
+function includes(test, search) {
+	return toArray(test).join("").toUpperCase().includes(search);
+}
+function useFilterOptions(options, fieldNames, searchValue, filterOption, optionFilterProp) {
+	return computed(() => {
+		if (!searchValue.value || filterOption.value === false) return options.value;
+		const { options: fieldOptions, label: fieldLabel, value: fieldValue } = fieldNames.value;
+		const filteredOptions = [];
+		const customizeFilter = typeof filterOption.value === "function";
+		const upperSearch = searchValue.value.toUpperCase();
+		const defaultFilter = (_, option) => {
+			if (optionFilterProp.value && option) return includes(option[optionFilterProp.value], upperSearch);
+			if (option && option[fieldOptions]) return includes(option[fieldLabel !== "children" ? fieldLabel : "label"], upperSearch);
+			return option ? includes(option[fieldValue], upperSearch) : false;
+		};
+		const filterFunc = customizeFilter ? filterOption.value : defaultFilter;
+		const wrapOption = customizeFilter ? (opt) => injectPropsWithOption(opt) : (opt) => opt;
+		options.value.forEach((item) => {
+			if (item[fieldOptions]) {
+				if (filterFunc(searchValue.value, wrapOption(item))) filteredOptions.push(item);
+				else {
+					const subOptions = item[fieldOptions].filter((subItem) => filterFunc(searchValue.value, wrapOption(subItem)));
+					if (subOptions.length) filteredOptions.push({
+						...item,
+						[fieldOptions]: subOptions
+					});
+				}
+				return;
+			}
+			if (filterFunc(searchValue.value, wrapOption(item))) filteredOptions.push(item);
+		});
+		return filteredOptions;
+	});
+}
+export { useFilterOptions as default };

package/dist/hooks/useLock.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useLock(duration = 250) {
+	const lockRef = (0, vue.shallowRef)(null);
+	const timeoutRef = (0, vue.shallowRef)(null);
+	function cleanup() {
+		if (timeoutRef.value !== null) {
+			window.clearTimeout(timeoutRef.value);
+			timeoutRef.value = null;
+		}
+	}
+	(0, vue.onUnmounted)(() => {
+		cleanup();
+	});
+	function doLock(locked) {
+		if (locked || lockRef.value === null) lockRef.value = locked;
+		cleanup();
+		timeoutRef.value = window.setTimeout(() => {
+			lockRef.value = null;
+			timeoutRef.value = null;
+		}, duration);
+	}
+	return [() => !!lockRef.value, doLock];
+}
+exports.default = useLock;

package/dist/hooks/useLock.d.ts

@@ -0,0 +1 @@
+export default function useLock(duration?: number): [() => boolean, (lock: boolean) => void];

package/dist/hooks/useLock.js

@@ -0,0 +1,24 @@
+import { onUnmounted, shallowRef } from "vue";
+function useLock(duration = 250) {
+	const lockRef = shallowRef(null);
+	const timeoutRef = shallowRef(null);
+	function cleanup() {
+		if (timeoutRef.value !== null) {
+			window.clearTimeout(timeoutRef.value);
+			timeoutRef.value = null;
+		}
+	}
+	onUnmounted(() => {
+		cleanup();
+	});
+	function doLock(locked) {
+		if (locked || lockRef.value === null) lockRef.value = locked;
+		cleanup();
+		timeoutRef.value = window.setTimeout(() => {
+			lockRef.value = null;
+			timeoutRef.value = null;
+		}, duration);
+	}
+	return [() => !!lockRef.value, doLock];
+}
+export { useLock as default };

package/dist/hooks/useOpen.cjs

@@ -0,0 +1,58 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function internalMacroTask(fn) {
+	const channel = new MessageChannel();
+	channel.port1.onmessage = fn;
+	channel.port2.postMessage(null);
+}
+function macroTask(fn, times = 1) {
+	if (times <= 0) {
+		fn();
+		return;
+	}
+	internalMacroTask(() => {
+		macroTask(fn, times - 1);
+	});
+}
+function useOpen(propOpen, onOpen, postOpen) {
+	const rendered = (0, vue.shallowRef)(false);
+	(0, vue.onMounted)(() => {
+		rendered.value = true;
+	});
+	const stateOpen = (0, vue.shallowRef)(false);
+	(0, vue.watch)(propOpen, () => {
+		stateOpen.value = propOpen.value;
+	});
+	const ssrSafeOpen = (0, vue.computed)(() => rendered.value ? stateOpen.value : false);
+	const mergedOpen = (0, vue.computed)(() => postOpen(ssrSafeOpen.value));
+	const taskIdRef = (0, vue.shallowRef)(0);
+	const taskLockRef = (0, vue.shallowRef)(false);
+	const triggerEvent = (nextOpen) => {
+		if (onOpen && mergedOpen.value !== nextOpen) onOpen(nextOpen);
+		stateOpen.value = nextOpen;
+	};
+	const toggleOpen = (nextOpen, config = {}) => {
+		const { ignoreNext = false, lazy = false } = config;
+		taskIdRef.value += 1;
+		const id = taskIdRef.value;
+		const nextOpenVal = typeof nextOpen === "boolean" ? nextOpen : !mergedOpen.value;
+		if (nextOpenVal !== lazy) {
+			if (!taskLockRef.value) {
+				triggerEvent(nextOpenVal);
+				if (ignoreNext) {
+					taskLockRef.value = ignoreNext;
+					macroTask(() => {
+						taskLockRef.value = false;
+					}, 2);
+				}
+			}
+			return;
+		}
+		macroTask(() => {
+			if (id === taskIdRef.value && !taskLockRef.value) triggerEvent(nextOpenVal);
+		});
+	};
+	return [mergedOpen, toggleOpen];
+}
+exports.default = useOpen;

package/dist/hooks/useOpen.d.ts

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+/**
+ * Trigger by latest open call, if nextOpen is undefined, means toggle.
+ * ignoreNext will skip next call in the macro task queue.
+ */
+export type TriggerOpenType = (nextOpen?: boolean, config?: {
+    ignoreNext?: boolean;
+    lazy?: boolean;
+}) => void;
+/**
+ * When `open` is controlled, follow the controlled value;
+ * Otherwise use uncontrolled logic.
+ * Setting `open` takes effect immediately,
+ * but setting it to `false` is delayed via MessageChannel.
+ *
+ * SSR handling: During SSR, `open` is always false to avoid Portal issues.
+ * On client-side hydration, it syncs with the actual open state.
+ */
+export default function useOpen(propOpen: Ref<boolean>, onOpen: (nextOpen: boolean) => void, postOpen: (nextOpen: boolean) => boolean): readonly [import('vue').ComputedRef<boolean>, TriggerOpenType];

package/dist/hooks/useOpen.js

@@ -0,0 +1,56 @@
+import { computed, onMounted, shallowRef, watch } from "vue";
+function internalMacroTask(fn) {
+	const channel = new MessageChannel();
+	channel.port1.onmessage = fn;
+	channel.port2.postMessage(null);
+}
+function macroTask(fn, times = 1) {
+	if (times <= 0) {
+		fn();
+		return;
+	}
+	internalMacroTask(() => {
+		macroTask(fn, times - 1);
+	});
+}
+function useOpen(propOpen, onOpen, postOpen) {
+	const rendered = shallowRef(false);
+	onMounted(() => {
+		rendered.value = true;
+	});
+	const stateOpen = shallowRef(false);
+	watch(propOpen, () => {
+		stateOpen.value = propOpen.value;
+	});
+	const ssrSafeOpen = computed(() => rendered.value ? stateOpen.value : false);
+	const mergedOpen = computed(() => postOpen(ssrSafeOpen.value));
+	const taskIdRef = shallowRef(0);
+	const taskLockRef = shallowRef(false);
+	const triggerEvent = (nextOpen) => {
+		if (onOpen && mergedOpen.value !== nextOpen) onOpen(nextOpen);
+		stateOpen.value = nextOpen;
+	};
+	const toggleOpen = (nextOpen, config = {}) => {
+		const { ignoreNext = false, lazy = false } = config;
+		taskIdRef.value += 1;
+		const id = taskIdRef.value;
+		const nextOpenVal = typeof nextOpen === "boolean" ? nextOpen : !mergedOpen.value;
+		if (nextOpenVal !== lazy) {
+			if (!taskLockRef.value) {
+				triggerEvent(nextOpenVal);
+				if (ignoreNext) {
+					taskLockRef.value = ignoreNext;
+					macroTask(() => {
+						taskLockRef.value = false;
+					}, 2);
+				}
+			}
+			return;
+		}
+		macroTask(() => {
+			if (id === taskIdRef.value && !taskLockRef.value) triggerEvent(nextOpenVal);
+		});
+	};
+	return [mergedOpen, toggleOpen];
+}
+export { useOpen as default };

package/dist/hooks/useOptions.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useOptions(options, childrenOptions, fieldNames, optionFilterProp, optionLabelProp) {
+	return (0, vue.computed)(() => {
+		let mergedOptions = [];
+		if (options.value && options.value.length > 0) mergedOptions = options.value;
+		else if (childrenOptions.value && childrenOptions.value.length > 0) mergedOptions = childrenOptions.value;
+		const valueOptions = /* @__PURE__ */ new Map();
+		const labelOptions = /* @__PURE__ */ new Map();
+		const setLabelOptions = (labelOptionsMap, option, key) => {
+			if (key && typeof key === "string") labelOptionsMap.set(option[key], option);
+		};
+		const dig = (optionList, isChildren = false) => {
+			if (!Array.isArray(optionList)) return;
+			for (let i = 0; i < optionList.length; i += 1) {
+				const option = optionList[i];
+				if (!option) continue;
+				const optionsKey = fieldNames.value?.options || "options";
+				const valueKey = fieldNames.value?.value || "value";
+				const labelKey = fieldNames.value?.label || "label";
+				if (!option[optionsKey] || isChildren) {
+					valueOptions.set(option[valueKey], option);
+					setLabelOptions(labelOptions, option, labelKey);
+					setLabelOptions(labelOptions, option, optionFilterProp.value);
+					setLabelOptions(labelOptions, option, optionLabelProp.value);
+				} else dig(option[optionsKey], true);
+			}
+		};
+		dig(mergedOptions);
+		return {
+			options: mergedOptions,
+			valueOptions,
+			labelOptions
+		};
+	});
+}
+exports.default = useOptions;

package/dist/hooks/useOptions.d.ts

@@ -0,0 +1,13 @@
+import { VueNode } from '@v-c/util/dist/type';
+import { Ref, ShallowRef } from 'vue';
+import { RawValueType } from '../interface';
+import { DefaultOptionType, FieldNames } from '../Select';
+export interface OptionsResult<OptionType> {
+    options: OptionType[];
+    valueOptions: Map<RawValueType, OptionType>;
+    labelOptions: Map<VueNode, OptionType>;
+}
+/**
+ * Parse `options` and flatten them.
+ */
+export default function useOptions<OptionType extends DefaultOptionType = DefaultOptionType>(options: Ref<OptionType[] | undefined>, childrenOptions: ShallowRef<OptionType[]>, fieldNames: Ref<FieldNames>, optionFilterProp: Ref<string | undefined>, optionLabelProp: Ref<string | undefined>): Ref<OptionsResult<OptionType>>;

package/dist/hooks/useOptions.js

@@ -0,0 +1,36 @@
+import { computed } from "vue";
+function useOptions(options, childrenOptions, fieldNames, optionFilterProp, optionLabelProp) {
+	return computed(() => {
+		let mergedOptions = [];
+		if (options.value && options.value.length > 0) mergedOptions = options.value;
+		else if (childrenOptions.value && childrenOptions.value.length > 0) mergedOptions = childrenOptions.value;
+		const valueOptions = /* @__PURE__ */ new Map();
+		const labelOptions = /* @__PURE__ */ new Map();
+		const setLabelOptions = (labelOptionsMap, option, key) => {
+			if (key && typeof key === "string") labelOptionsMap.set(option[key], option);
+		};
+		const dig = (optionList, isChildren = false) => {
+			if (!Array.isArray(optionList)) return;
+			for (let i = 0; i < optionList.length; i += 1) {
+				const option = optionList[i];
+				if (!option) continue;
+				const optionsKey = fieldNames.value?.options || "options";
+				const valueKey = fieldNames.value?.value || "value";
+				const labelKey = fieldNames.value?.label || "label";
+				if (!option[optionsKey] || isChildren) {
+					valueOptions.set(option[valueKey], option);
+					setLabelOptions(labelOptions, option, labelKey);
+					setLabelOptions(labelOptions, option, optionFilterProp.value);
+					setLabelOptions(labelOptions, option, optionLabelProp.value);
+				} else dig(option[optionsKey], true);
+			}
+		};
+		dig(mergedOptions);
+		return {
+			options: mergedOptions,
+			valueOptions,
+			labelOptions
+		};
+	});
+}
+export { useOptions as default };

package/dist/hooks/useRefFunc.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useRefFunc(callback) {
+	const funcRef = (0, vue.shallowRef)(callback);
+	funcRef.value = callback;
+	const cacheFn = (...args) => {
+		return funcRef.value(...args);
+	};
+	return cacheFn;
+}
+exports.default = useRefFunc;

package/dist/hooks/useRefFunc.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Same as `React.useCallback` but always return a memoized function
+ * but redirect to real function.
+ * In Vue, we use shallowRef to store the callback reference.
+ */
+export default function useRefFunc<T extends (...args: any[]) => any>(callback: T): T;

package/dist/hooks/useRefFunc.js

@@ -0,0 +1,10 @@
+import { shallowRef } from "vue";
+function useRefFunc(callback) {
+	const funcRef = shallowRef(callback);
+	funcRef.value = callback;
+	const cacheFn = (...args) => {
+		return funcRef.value(...args);
+	};
+	return cacheFn;
+}
+export { useRefFunc as default };

package/dist/hooks/useSearchConfig.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useSearchConfig(showSearch, props, mode) {
+	const { filterOption, searchValue, optionFilterProp, filterSort, onSearch, autoClearSearchValue } = props;
+	return [(0, vue.computed)(() => {
+		return typeof showSearch.value === "object" || mode.value === "combobox" || mode.value === "tags" || mode.value === "multiple" && showSearch.value === void 0 ? true : showSearch.value;
+	}), (0, vue.computed)(() => {
+		const isObject = typeof showSearch.value === "object";
+		return {
+			filterOption: filterOption?.value,
+			searchValue: searchValue?.value,
+			optionFilterProp: optionFilterProp?.value,
+			filterSort: filterSort?.value,
+			onSearch: onSearch?.value,
+			autoClearSearchValue: autoClearSearchValue?.value,
+			...isObject ? showSearch.value : {}
+		};
+	})];
+}
+exports.default = useSearchConfig;

package/dist/hooks/useSearchConfig.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { SearchConfig, SelectProps } from '../Select';
+export type SearchConfigResult = [Ref<boolean | undefined>, Ref<SearchConfig>];
+export default function useSearchConfig(showSearch: Ref<boolean | SearchConfig | undefined>, props: {
+    filterOption?: Ref<SelectProps['filterOption']>;
+    searchValue?: Ref<string | undefined>;
+    optionFilterProp?: Ref<string | undefined>;
+    filterSort?: Ref<SelectProps['filterSort']>;
+    onSearch?: Ref<((value: string) => void) | undefined>;
+    autoClearSearchValue?: Ref<boolean | undefined>;
+}, mode: Ref<SelectProps['mode']>): SearchConfigResult;

package/dist/hooks/useSearchConfig.js

@@ -0,0 +1,19 @@
+import { computed } from "vue";
+function useSearchConfig(showSearch, props, mode) {
+	const { filterOption, searchValue, optionFilterProp, filterSort, onSearch, autoClearSearchValue } = props;
+	return [computed(() => {
+		return typeof showSearch.value === "object" || mode.value === "combobox" || mode.value === "tags" || mode.value === "multiple" && showSearch.value === void 0 ? true : showSearch.value;
+	}), computed(() => {
+		const isObject = typeof showSearch.value === "object";
+		return {
+			filterOption: filterOption?.value,
+			searchValue: searchValue?.value,
+			optionFilterProp: optionFilterProp?.value,
+			filterSort: filterSort?.value,
+			onSearch: onSearch?.value,
+			autoClearSearchValue: autoClearSearchValue?.value,
+			...isObject ? showSearch.value : {}
+		};
+	})];
+}
+export { useSearchConfig as default };

package/dist/hooks/useSelectTriggerControl.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_rolldown_runtime = require("../_virtual/rolldown_runtime.cjs");
+let vue = require("vue");
+function useSelectTriggerControl(elements, open, triggerOpen, customizedTrigger) {
+	const onGlobalMouseDown = (event) => {
+		if (customizedTrigger.value) return;
+		let target = event.target;
+		if (target.shadowRoot && event.composed) target = event.composedPath()[0] || target;
+		if (open.value && elements().filter((element) => element).every((element) => !element.contains(target) && element !== target)) triggerOpen(false);
+	};
+	(0, vue.onMounted)(() => {
+		window.addEventListener("mousedown", onGlobalMouseDown);
+		(0, vue.onUnmounted)(() => {
+			window.removeEventListener("mousedown", onGlobalMouseDown);
+		});
+	});
+}
+exports.default = useSelectTriggerControl;

package/dist/hooks/useSelectTriggerControl.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useSelectTriggerControl(elements: () => (HTMLElement | SVGElement | undefined)[], open: Ref<boolean>, triggerOpen: (open: boolean) => void, customizedTrigger: Ref<boolean>): void;

package/dist/hooks/useSelectTriggerControl.js

@@ -0,0 +1,16 @@
+import { onMounted, onUnmounted } from "vue";
+function useSelectTriggerControl(elements, open, triggerOpen, customizedTrigger) {
+	const onGlobalMouseDown = (event) => {
+		if (customizedTrigger.value) return;
+		let target = event.target;
+		if (target.shadowRoot && event.composed) target = event.composedPath()[0] || target;
+		if (open.value && elements().filter((element) => element).every((element) => !element.contains(target) && element !== target)) triggerOpen(false);
+	};
+	onMounted(() => {
+		window.addEventListener("mousedown", onGlobalMouseDown);
+		onUnmounted(() => {
+			window.removeEventListener("mousedown", onGlobalMouseDown);
+		});
+	});
+}
+export { useSelectTriggerControl as default };