sard 1.0.0 → 1.0.2

package/components/select/select.js

@@ -0,0 +1,268 @@
+import { createBem } from "../../utils/bem.js";
+import { debounce } from "../../utils/utils.js";
+import { scrollToTarget } from "../../utils/geometry.js";
+import { useScrollSide } from "../../use/useScrollSide.js";
+import { usePopupEnter } from "../popup/common.js";
+import { useOptionKeys } from "../../use/useOptionKeys.js";
+import loading_default from "../loading/loading.js";
+import { useTranslateWithPrefix } from "../../locale/index.js";
+import button_default from "../button/button.js";
+import input_default from "../input/input.js";
+import empty_default from "../empty/empty.js";
+import load_more_default from "../load-more/load-more.js";
+import { useLoadMore } from "../load-more/useLoadMore.js";
+import { defaultSelectProps } from "./common.js";
+import select_option_group_default from "./select-option-group.js";
+import select_option_default from "./select-option.js";
+import { useSelect } from "./useSelect.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createTextVNode, createVNode, defineComponent, mergeDefaults, mergeProps, normalizeClass, onBeforeUnmount, openBlock, ref, renderList, renderSlot, toDisplayString, unref, useSlots, useTemplateRef, watch, withCtx } from "vue";
+import { Search } from "@sard/icons";
+//#region packages/sard/components/select/select.vue
+const _hoisted_1 = {
+	key: 1,
+	ref: "load-more"
+};
+var select_default = /*@__PURE__*/ defineComponent({
+	__name: "select",
+	props: /*@__PURE__*/ mergeDefaults({
+		modelValue: {
+			type: null,
+			required: false
+		},
+		multiple: {
+			type: Boolean,
+			required: false
+		},
+		multipleLimit: {
+			type: Number,
+			required: false
+		},
+		filterable: {
+			type: Boolean,
+			required: false
+		},
+		filterPlaceholder: {
+			type: String,
+			required: false
+		},
+		filterMethod: {
+			type: Function,
+			required: false
+		},
+		remote: {
+			type: Boolean,
+			required: false
+		},
+		remoteMethod: {
+			type: Function,
+			required: false
+		},
+		threshold: {
+			type: Number,
+			required: false
+		},
+		showToolbar: {
+			type: Boolean,
+			required: false
+		},
+		options: {
+			type: Array,
+			required: false
+		},
+		optionKeys: {
+			type: Object,
+			required: false
+		},
+		valueKey: {
+			type: String,
+			required: false
+		}
+	}, defaultSelectProps),
+	emits: [
+		"update:modelValue",
+		"change",
+		"select"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const slots = useSlots();
+		const emit = __emit;
+		const bem = createBem("select");
+		const { t } = useTranslateWithPrefix("select");
+		const { getLabel, getValue, getChildren, getKey } = useOptionKeys(props);
+		const isGroupable = computed(() => {
+			const first = props.options[0];
+			return first && Array.isArray(getChildren(first));
+		});
+		const { innerValue, members, getEnabledValue } = useSelect(props, {
+			onToggle(value) {
+				triggerChange(value);
+			},
+			onSelect(value) {
+				emit("select", value);
+			}
+		});
+		watch(() => props.modelValue, (value) => {
+			innerValue.value = props.multiple ? Array.isArray(value) ? value : [] : value;
+		}, { immediate: true });
+		const triggerChange = (nextValue) => {
+			innerValue.value = nextValue;
+			emit("update:modelValue", nextValue);
+			emit("change", nextValue);
+		};
+		const scrollRef = useTemplateRef("scroll");
+		const scrollSide = useScrollSide(scrollRef, { direction: "vertical" });
+		const searchValue = ref("");
+		watch(searchValue, () => {
+			props.filterMethod?.(searchValue.value);
+			debouncedRefresh();
+		});
+		const { status, isLoading, onLoadMore, onReload, refresh } = useLoadMore({
+			root: scrollRef,
+			target: useTemplateRef("load-more"),
+			disabled: () => !props.remote || !props.remoteMethod,
+			request: async (page, isRefresh) => {
+				return props.remoteMethod(searchValue.value, page, isRefresh).then((loaded) => {
+					if (isRefresh && scrollRef.value) scrollRef.value.scrollTop = 0;
+					return loaded;
+				});
+			}
+		});
+		const debouncedRefresh = debounce(refresh, props.threshold);
+		onBeforeUnmount(() => {
+			debouncedRefresh.cancel();
+		});
+		const isEmpty = computed(() => {
+			return members.length === 0 && (props.remote ? status.value === "complete" : true);
+		});
+		const onClear = () => {
+			if (innerValue.value.length > 0) triggerChange([]);
+		};
+		const onSelectAll = () => {
+			triggerChange(getEnabledValue());
+		};
+		const showSelectAll = computed(() => {
+			return props.multiple && props.multipleLimit <= 0;
+		});
+		function scrollIntoView() {
+			const member = members.find((member) => member.isSelected);
+			if (member && member.el) scrollToTarget(scrollRef.value, member.el, { vertical: true });
+		}
+		watch(innerValue, () => {
+			if (!props.multiple) scrollIntoView();
+		}, {
+			flush: "post",
+			immediate: true
+		});
+		usePopupEnter(() => {
+			scrollIntoView();
+		});
+		__expose({});
+		const containerClass = computed(() => {
+			return [bem.e("container"), bem.em("container", scrollSide.vertical)];
+		});
+		const scrollClass = computed(() => {
+			return [bem.e("scroll"), bem.em("scroll", "filterable", props.filterable)];
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(unref(bem).b()) }, [
+				__props.filterable ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(unref(bem).e("search"))
+				}, [createVNode(input_default, {
+					modelValue: searchValue.value,
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => searchValue.value = $event),
+					placeholder: __props.filterPlaceholder,
+					clearable: ""
+				}, {
+					prepend: withCtx(() => [createVNode(unref(Search))]),
+					append: withCtx(() => [unref(isLoading) ? (openBlock(), createBlock(loading_default, {
+						key: 0,
+						class: normalizeClass(unref(bem).e("loading"))
+					}, null, 8, ["class"])) : createCommentVNode("v-if", true)]),
+					_: 1
+				}, 8, ["modelValue", "placeholder"])], 2)) : createCommentVNode("v-if", true),
+				createElementVNode("div", { class: normalizeClass(containerClass.value) }, [createElementVNode("div", {
+					ref: "scroll",
+					class: normalizeClass(scrollClass.value)
+				}, [
+					renderSlot(_ctx.$slots, "default", {}, () => [isGroupable.value ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(__props.options, (group) => {
+						return openBlock(), createBlock(select_option_group_default, {
+							key: unref(getKey)(unref(getValue)(group)),
+							label: unref(getLabel)(group),
+							value: unref(getValue)(group)
+						}, {
+							default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(getChildren)(group), (item) => {
+								return openBlock(), createBlock(select_option_default, {
+									key: unref(getKey)(unref(getValue)(item)),
+									label: unref(getLabel)(item),
+									value: unref(getValue)(item)
+								}, createSlots({ _: 2 }, [slots["option"] ? {
+									name: "default",
+									fn: withCtx((optionProps) => [renderSlot(_ctx.$slots, "option", mergeProps({ ref_for: true }, optionProps))]),
+									key: "0"
+								} : void 0, slots["option-label"] ? {
+									name: "label",
+									fn: withCtx((labelProps) => [renderSlot(_ctx.$slots, "option-label", mergeProps({ ref_for: true }, labelProps))]),
+									key: "1"
+								} : void 0]), 1032, ["label", "value"]);
+							}), 128))]),
+							_: 2
+						}, 1032, ["label", "value"]);
+					}), 128)) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(__props.options, (item) => {
+						return openBlock(), createBlock(select_option_default, {
+							key: unref(getKey)(unref(getValue)(item)),
+							label: unref(getLabel)(item),
+							value: unref(getValue)(item)
+						}, createSlots({ _: 2 }, [slots["option"] ? {
+							name: "default",
+							fn: withCtx((optionProps) => [renderSlot(_ctx.$slots, "option", mergeProps({ ref_for: true }, optionProps))]),
+							key: "0"
+						} : void 0, slots["option-label"] ? {
+							name: "label",
+							fn: withCtx((labelProps) => [renderSlot(_ctx.$slots, "option-label", mergeProps({ ref_for: true }, labelProps))]),
+							key: "1"
+						} : void 0]), 1032, ["label", "value"]);
+					}), 128))]),
+					isEmpty.value ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						class: normalizeClass(unref(bem).e("empty"))
+					}, [createVNode(empty_default, { size: "small" })], 2)) : createCommentVNode("v-if", true),
+					__props.remote && !isEmpty.value ? (openBlock(), createElementBlock("div", _hoisted_1, [createVNode(load_more_default, {
+						status: unref(status),
+						onLoadMore: unref(onLoadMore),
+						onReload: unref(onReload)
+					}, null, 8, [
+						"status",
+						"onLoadMore",
+						"onReload"
+					])], 512)) : createCommentVNode("v-if", true)
+				], 2)], 2),
+				__props.multiple && __props.showToolbar ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					class: normalizeClass(unref(bem).e("toolbar"))
+				}, [
+					createElementVNode("div", { class: normalizeClass(unref(bem).e("num")) }, toDisplayString(unref(t)("selected", { num: unref(innerValue).length })), 3),
+					createVNode(button_default, {
+						variant: "link",
+						color: "secondary",
+						onClick: onClear
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("clearSelect")), 1)]),
+						_: 1
+					}),
+					showSelectAll.value ? (openBlock(), createBlock(button_default, {
+						key: 0,
+						variant: "link",
+						onClick: onSelectAll
+					}, {
+						default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("selectAll")), 1)]),
+						_: 1
+					})) : createCommentVNode("v-if", true)
+				], 2)) : createCommentVNode("v-if", true)
+			], 2);
+		};
+	}
+});
+//#endregion
+export { select_default as default };

package/components/select/useSelect.d.ts

@@ -0,0 +1,8 @@
+import { type SelectContext } from './common';
+export declare function useSelect(props: {
+    multiple: boolean;
+    multipleLimit: number;
+}, options?: {
+    onToggle?: (value: any) => void;
+    onSelect?: (value: any) => void;
+}): SelectContext;

package/components/select/useSelect.js

@@ -0,0 +1,45 @@
+import { selectContextKey } from "./common.js";
+import { provide, reactive, ref, toRef, toValue } from "vue";
+//#region packages/sard/components/select/useSelect.ts
+function useSelect(props, options = {}) {
+	const innerValue = ref(props.multiple ? [] : void 0);
+	const { onToggle, onSelect } = options;
+	const members = reactive([]);
+	const addMember = (member) => {
+		if (!members.includes(member)) members.push(member);
+	};
+	const removeMember = (member) => {
+		const index = members.indexOf(member);
+		if (index !== -1) members.splice(index, 1);
+	};
+	const getEnabledValue = () => {
+		return members.filter((member) => !toValue(member.disabled)).map((member) => member.value);
+	};
+	const toggle = (value) => {
+		let nextValue;
+		if (props.multiple) nextValue = innerValue.value.includes(value) ? innerValue.value.filter((val) => val !== value) : innerValue.value.concat(value);
+		else {
+			if (value === innerValue.value) {
+				onSelect?.(value);
+				return;
+			}
+			nextValue = value;
+		}
+		onToggle?.(nextValue);
+		onSelect?.(value);
+	};
+	const context = {
+		innerValue,
+		toggle,
+		multiple: toRef(() => props.multiple),
+		multipleLimit: toRef(() => props.multipleLimit),
+		members,
+		addMember,
+		removeMember,
+		getEnabledValue
+	};
+	provide(selectContextKey, context);
+	return context;
+}
+//#endregion
+export { useSelect };

package/components/select-input/common.d.ts

@@ -0,0 +1,14 @@
+import { type DefaultProps } from '../config';
+import { type SelectPopoutEmits, type SelectPopoutProps, type SelectPopoutSlots } from '../select-popout/common';
+import { type PopoutInputSlots, type PopoutInputProps } from '../popout-input/common';
+export interface SelectInputProps extends SelectPopoutProps, Omit<PopoutInputProps, 'modelValue'> {
+    maxLabels?: number;
+    mapLabel?: Record<any, any>;
+}
+export declare const defaultSelectInputProps: DefaultProps<SelectInputProps>;
+export interface SelectInputSlots extends SelectPopoutSlots, Omit<PopoutInputSlots, 'default'> {
+}
+export interface SelectInputEmits extends SelectPopoutEmits {
+}
+export interface SelectInputExpose {
+}

package/components/select-input/common.js

@@ -0,0 +1,8 @@
+import { defaultSelectPopoutProps } from "../select-popout/common.js";
+//#region packages/sard/components/select-input/common.ts
+const defaultSelectInputProps = {
+	...defaultSelectPopoutProps,
+	maxLabels: 10
+};
+//#endregion
+export { defaultSelectInputProps };

package/components/select-input/index.d.ts

@@ -0,0 +1,5 @@
+import { type EnhancedComponent } from '../../utils';
+import _SelectInput from './select-input.vue';
+export declare const SelectInput: EnhancedComponent<typeof _SelectInput>;
+export default SelectInput;
+export type { SelectInputProps, SelectInputSlots, SelectInputEmits, SelectInputExpose, } from './common';

package/components/select-input/index.js

@@ -0,0 +1,6 @@
+import { enhanceComponent } from "../../utils/component.js";
+import select_input_default from "./select-input.js";
+//#region packages/sard/components/select-input/index.ts
+const SelectInput = enhanceComponent(select_input_default);
+//#endregion
+export { SelectInput, SelectInput as default };

package/components/select-input/select-input.d.ts

@@ -0,0 +1,68 @@
+import { type SelectInputProps, type SelectInputSlots, type SelectInputExpose } from './common';
+type __VLS_Slots = SelectInputSlots;
+declare const __VLS_base: import("vue").DefineComponent<SelectInputProps, SelectInputExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (value: any) => any;
+    "before-enter": (el: Element) => any;
+    enter: (el: Element) => any;
+    "after-enter": (el: Element) => any;
+    "enter-cancelled": (el: Element) => any;
+    "before-leave": (el: Element) => any;
+    leave: (el: Element) => any;
+    "after-leave": (el: Element) => any;
+    "leave-cancelled": (el: Element) => any;
+    "visible-hook": (name: import("../index.ts").MotionHookName, el: Element) => any;
+    "update:visible": (visible: boolean) => any;
+    "update:modelValue": (value: any) => any;
+    confirm: () => any;
+}, string, import("vue").PublicProps, Readonly<SelectInputProps> & Readonly<{
+    onChange?: ((value: any) => any) | undefined;
+    "onBefore-enter"?: ((el: Element) => any) | undefined;
+    onEnter?: ((el: Element) => any) | undefined;
+    "onAfter-enter"?: ((el: Element) => any) | undefined;
+    "onEnter-cancelled"?: ((el: Element) => any) | undefined;
+    "onBefore-leave"?: ((el: Element) => any) | undefined;
+    onLeave?: ((el: Element) => any) | undefined;
+    "onAfter-leave"?: ((el: Element) => any) | undefined;
+    "onLeave-cancelled"?: ((el: Element) => any) | undefined;
+    "onVisible-hook"?: ((name: import("../index.ts").MotionHookName, el: Element) => any) | undefined;
+    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    title: string;
+    multiple: boolean;
+    options: any[];
+    readonly: boolean;
+    visible: boolean;
+    loading: boolean;
+    threshold: number;
+    disabled: boolean;
+    modelValue: any;
+    showConfirm: boolean;
+    optionKeys: import("../../use").OptionKeys;
+    placeholder: string;
+    clearable: boolean;
+    validateEvent: boolean;
+    multiline: boolean;
+    inputProps: import("../index.ts").InputProps;
+    valueOnClear: () => any;
+    resettable: boolean;
+    filterPlaceholder: string;
+    multipleLimit: number;
+    filterable: boolean;
+    filterMethod: (query: string) => void;
+    remote: boolean;
+    remoteMethod: (query: string, page: number, isRefresh: boolean) => Promise<boolean>;
+    showToolbar: boolean;
+    valueKey: string;
+    maxLabels: number;
+    mapLabel: Record<any, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/select-input/select-input.js

@@ -0,0 +1,258 @@
+import { isEmptyArray } from "../../utils/is.js";
+import { isEmptyBinding } from "../../utils/utils.js";
+import { useOptionKeys } from "../../use/useOptionKeys.js";
+import popout_input_default from "../popout-input/popout-input.js";
+import { partitionPopoutInputProps, usePopoutInput } from "../popout-input/usePopoutInput.js";
+import select_popout_default from "../select-popout/select-popout.js";
+import { defaultSelectInputProps } from "./common.js";
+import { computed, createBlock, createSlots, createVNode, defineComponent, guardReactiveProps, isRef, mergeDefaults, mergeProps, normalizeProps, openBlock, renderSlot, unref, useSlots, watch, withCtx } from "vue";
+//#region packages/sard/components/select-input/select-input.vue
+var select_input_default = /*@__PURE__*/ defineComponent({
+	__name: "select-input",
+	props: /*@__PURE__*/ mergeDefaults({
+		maxLabels: {
+			type: Number,
+			required: false
+		},
+		mapLabel: {
+			type: Object,
+			required: false
+		},
+		visible: {
+			type: Boolean,
+			required: false
+		},
+		title: {
+			type: String,
+			required: false
+		},
+		resettable: {
+			type: Boolean,
+			required: false
+		},
+		validateEvent: {
+			type: Boolean,
+			required: false
+		},
+		showConfirm: {
+			type: Boolean,
+			required: false
+		},
+		modelValue: {
+			type: null,
+			required: false
+		},
+		multiple: {
+			type: Boolean,
+			required: false
+		},
+		multipleLimit: {
+			type: Number,
+			required: false
+		},
+		filterable: {
+			type: Boolean,
+			required: false
+		},
+		filterPlaceholder: {
+			type: String,
+			required: false
+		},
+		filterMethod: {
+			type: Function,
+			required: false
+		},
+		remote: {
+			type: Boolean,
+			required: false
+		},
+		remoteMethod: {
+			type: Function,
+			required: false
+		},
+		threshold: {
+			type: Number,
+			required: false
+		},
+		showToolbar: {
+			type: Boolean,
+			required: false
+		},
+		options: {
+			type: Array,
+			required: false
+		},
+		optionKeys: {
+			type: Object,
+			required: false
+		},
+		valueKey: {
+			type: String,
+			required: false
+		},
+		placeholder: {
+			type: String,
+			required: false
+		},
+		readonly: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		clearable: {
+			type: Boolean,
+			required: false
+		},
+		loading: {
+			type: Boolean,
+			required: false
+		},
+		multiline: {
+			type: Boolean,
+			required: false
+		},
+		inputProps: {
+			type: Object,
+			required: false
+		},
+		valueOnClear: {
+			type: Function,
+			required: false
+		}
+	}, defaultSelectInputProps),
+	emits: [
+		"update:visible",
+		"update:modelValue",
+		"change",
+		"confirm",
+		"before-enter",
+		"enter",
+		"after-enter",
+		"enter-cancelled",
+		"before-leave",
+		"leave",
+		"after-leave",
+		"leave-cancelled",
+		"visible-hook"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const slots = useSlots();
+		const emit = __emit;
+		const { getLabel, getValue, getChildren } = useOptionKeys(props);
+		const partitionedProps = partitionPopoutInputProps(props);
+		const { innerVisible, innerValue, inputValue, show, onChange, onClear, onVisibleHook } = usePopoutInput(props, emit);
+		const isGroupable = computed(() => {
+			const first = props.options[0];
+			return first && Array.isArray(getChildren(first));
+		});
+		const labelCache = {};
+		watch(() => props.mapLabel, () => {
+			if (props.mapLabel) Object.assign(labelCache, props.mapLabel);
+		}, { immediate: true });
+		const getCacheLabel = (option, value) => {
+			if (option) return labelCache[value] = getLabel(option);
+			else return labelCache[value] ?? value;
+		};
+		function getOutletText(options, value) {
+			if (isGroupable.value) options = options.map((option) => getChildren(option)).flat(1);
+			if (props.multiple) {
+				if (!Array.isArray(value)) return "";
+				let labels = value.map((val) => {
+					const option = options.find((option) => getValue(option) === val);
+					return getCacheLabel(option, val);
+				});
+				const maxLabels = props.maxLabels === -1 ? Number.MAX_SAFE_INTEGER : props.maxLabels;
+				const diff = labels.length - maxLabels;
+				labels = labels.slice(0, maxLabels);
+				if (diff > 0) labels.push(`+${diff}`);
+				return labels.join(", ");
+			} else {
+				const option = options.find((option) => getValue(option) === value);
+				return getCacheLabel(option, value);
+			}
+		}
+		function getInputValue() {
+			if (isEmptyBinding(innerValue.value) || isEmptyArray(innerValue.value)) return "";
+			return getOutletText(props.options, innerValue.value);
+		}
+		watch([
+			innerValue,
+			() => props.options,
+			() => props.maxLabels
+		], () => {
+			inputValue.value = getInputValue();
+		}, { immediate: true });
+		const onConfirm = () => {
+			emit("confirm");
+		};
+		__expose({});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(popout_input_default, mergeProps(unref(partitionedProps)[0], {
+				modelValue: unref(inputValue),
+				"onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => isRef(inputValue) ? inputValue.value = $event : null),
+				multiline: __props.multiple,
+				onClear: unref(onClear),
+				onClick: unref(show)
+			}), createSlots({
+				default: withCtx(() => [createVNode(select_popout_default, mergeProps(unref(partitionedProps)[1], {
+					visible: unref(innerVisible),
+					"onUpdate:visible": _cache[0] || (_cache[0] = ($event) => isRef(innerVisible) ? innerVisible.value = $event : null),
+					modelValue: unref(innerValue),
+					"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(innerValue) ? innerValue.value = $event : null),
+					onChange: unref(onChange),
+					onVisibleHook: unref(onVisibleHook),
+					onConfirm
+				}), createSlots({ _: 2 }, [
+					slots.default ? {
+						name: "default",
+						fn: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+						key: "0"
+					} : void 0,
+					slots.option ? {
+						name: "option",
+						fn: withCtx((optionProps) => [renderSlot(_ctx.$slots, "option", normalizeProps(guardReactiveProps(optionProps)))]),
+						key: "1"
+					} : void 0,
+					slots["option-label"] ? {
+						name: "option-label",
+						fn: withCtx((labelProps) => [renderSlot(_ctx.$slots, "option-label", normalizeProps(guardReactiveProps(labelProps)))]),
+						key: "2"
+					} : void 0
+				]), 1040, [
+					"visible",
+					"modelValue",
+					"onChange",
+					"onVisibleHook"
+				])]),
+				_: 2
+			}, [
+				slots.prepend ? {
+					name: "prepend",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "prepend")]),
+					key: "0"
+				} : void 0,
+				slots.append ? {
+					name: "append",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "append")]),
+					key: "1"
+				} : void 0,
+				slots.arrow ? {
+					name: "arrow",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "arrow")]),
+					key: "2"
+				} : void 0
+			]), 1040, [
+				"modelValue",
+				"multiline",
+				"onClear",
+				"onClick"
+			]);
+		};
+	}
+});
+//#endregion
+export { select_input_default as default };