@sdata/web-vue 3.30.0 → 4.1.0

package/es/mention/mention.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,376 @@
+import { useFormItem } from "../_hooks/use-form-item.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/objectSpread2.js";
+import { getPrefixCls } from "../_utils/global-config.js";
+import { isNull, isUndefined } from "../_utils/is.js";
+import resize_observer_default from "../_components/resize-observer.js";
+import { useAllowClear } from "../_hooks/use-allow-clear.js";
+import Trigger from "../trigger/index.js";
+import Input from "../input/index.js";
+import { getKeyFromValue } from "../select/utils.js";
+import { useSelect } from "../select/hooks/use-select.js";
+import select_dropdown_default from "../select/select-dropdown.js";
+import { getSizeStyles } from "../textarea/utils.js";
+import Textarea from "../textarea/index.js";
+import { getLastMeasureIndex, getTextBeforeSelection, isValidSearch } from "./utils.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createTextVNode, createVNode, defineComponent, mergeProps, nextTick, normalizeClass, normalizeStyle, onMounted, openBlock, ref, renderList, renderSlot, toDisplayString, toRef, unref, useAttrs, useSlots, watch, withCtx } from "vue";
+import { createReusableTemplate } from "@vueuse/core";
+//#region components/mention/mention.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"aria-disabled",
+	"onClick",
+	"onMouseenter",
+	"onMouseleave"
+];
+var mention_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent(_objectSpread2(_objectSpread2({}, {
+	name: "Mention",
+	inheritAttrs: false
+}), {}, {
+	__name: "mention",
+	props: {
+		modelValue: String,
+		defaultValue: {
+			type: String,
+			default: ""
+		},
+		data: {
+			type: Array,
+			default: () => []
+		},
+		prefix: {
+			type: [String, Array],
+			default: "@"
+		},
+		split: {
+			type: String,
+			default: " "
+		},
+		type: {
+			type: String,
+			default: "input"
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		readonly: {
+			type: [Boolean, String],
+			default: false
+		},
+		allowClear: {
+			type: Boolean,
+			default: false
+		},
+		fitWidth: {
+			type: Boolean,
+			default: false
+		},
+		maxWFull: {
+			type: Boolean,
+			default: true
+		},
+		floatingOptions: Object
+	},
+	emits: {
+		"update:modelValue": (_value) => true,
+		"change": (_value) => true,
+		"search": (_value, _prefix) => true,
+		"select": (_value) => true,
+		"clear": (_event) => true,
+		"focus": (_event) => true,
+		"blur": (_event) => true
+	},
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const attrs = useAttrs();
+		const slots = useSlots();
+		const [DefineDropdown, ReuseDropdown] = createReusableTemplate();
+		const prefixCls = getPrefixCls("mention");
+		const optionPrefixCls = getPrefixCls("select-option");
+		const { mergedAllowClear } = useAllowClear(toRef(props, "allowClear"));
+		const { mergedDisabled, eventHandlers } = useFormItem({ disabled: toRef(props, "disabled") });
+		const dropdownRef = ref();
+		const optionRefs = ref({});
+		const innerValue = ref(props.defaultValue);
+		const computedValue = computed(() => {
+			var _props$modelValue;
+			return (_props$modelValue = props.modelValue) !== null && _props$modelValue !== void 0 ? _props$modelValue : innerValue.value;
+		});
+		watch(toRef(props, "modelValue"), (value) => {
+			if (isUndefined(value) || isNull(value)) innerValue.value = "";
+		});
+		const computedValueKeys = computed(() => computedValue.value ? [getKeyFromValue(computedValue.value)] : []);
+		const measureInfo = ref({
+			measuring: false,
+			location: -1,
+			prefix: "",
+			text: ""
+		});
+		const resetMeasureInfo = () => {
+			measureInfo.value = {
+				measuring: false,
+				location: -1,
+				prefix: "",
+				text: ""
+			};
+		};
+		const inputRef = ref();
+		const measureText = computed(() => measureInfo.value.text);
+		const filterOption = ref(true);
+		const innerPopupVisible = ref(false);
+		const computedPopupVisible = computed(() => innerPopupVisible.value && measureInfo.value.measuring && validOptionInfos.value.length > 0);
+		const handleInput = (value, event) => {
+			var _eventHandlers$value, _eventHandlers$value$;
+			if (props.readonly) return;
+			const text = getTextBeforeSelection(event.target);
+			const lastMeasure = getLastMeasureIndex(text, props.prefix);
+			if (lastMeasure.location > -1) {
+				const textAfterPrefix = text.slice(lastMeasure.location + lastMeasure.prefix.length);
+				if (isValidSearch(textAfterPrefix, props.split)) {
+					innerPopupVisible.value = true;
+					measureInfo.value = _objectSpread2({
+						measuring: true,
+						text: textAfterPrefix
+					}, lastMeasure);
+					emit("search", textAfterPrefix, lastMeasure.prefix);
+				} else if (measureInfo.value.location > -1) resetMeasureInfo();
+			} else if (measureInfo.value.location > -1) resetMeasureInfo();
+			innerValue.value = value;
+			emit("update:modelValue", value);
+			emit("change", value);
+			(_eventHandlers$value = eventHandlers.value) === null || _eventHandlers$value === void 0 || (_eventHandlers$value$ = _eventHandlers$value.onChange) === null || _eventHandlers$value$ === void 0 || _eventHandlers$value$.call(_eventHandlers$value);
+		};
+		const handleClear = (event) => {
+			var _eventHandlers$value2, _eventHandlers$value3;
+			innerValue.value = "";
+			resetMeasureInfo();
+			innerPopupVisible.value = false;
+			emit("update:modelValue", "");
+			emit("change", "");
+			(_eventHandlers$value2 = eventHandlers.value) === null || _eventHandlers$value2 === void 0 || (_eventHandlers$value3 = _eventHandlers$value2.onChange) === null || _eventHandlers$value3 === void 0 || _eventHandlers$value3.call(_eventHandlers$value2);
+			emit("clear", event);
+		};
+		const handlePopupVisibleChange = (visible) => {
+			innerPopupVisible.value = visible;
+		};
+		const handleSelect = (key, _event) => {
+			var _optionInfoMap$get, _eventHandlers$value4, _eventHandlers$value5;
+			const { value } = (_optionInfoMap$get = optionInfoMap.get(key)) !== null && _optionInfoMap$get !== void 0 ? _optionInfoMap$get : {};
+			const measureStart = measureInfo.value.location;
+			const measureEnd = measureStart + measureInfo.value.text.length;
+			let head = innerValue.value.slice(0, measureStart);
+			let tail = innerValue.value.slice(measureEnd + 1);
+			head += !head || head.endsWith(props.split) || head.endsWith("\n") ? "" : props.split;
+			tail = (!tail || tail.startsWith(props.split) || tail.startsWith("\n") ? "" : props.split) + tail;
+			const nextValue = `${head}${measureInfo.value.prefix}${value}${tail}`;
+			innerValue.value = nextValue;
+			emit("select", value);
+			emit("update:modelValue", nextValue);
+			emit("change", nextValue);
+			resetMeasureInfo();
+			(_eventHandlers$value4 = eventHandlers.value) === null || _eventHandlers$value4 === void 0 || (_eventHandlers$value5 = _eventHandlers$value4.onChange) === null || _eventHandlers$value5 === void 0 || _eventHandlers$value5.call(_eventHandlers$value4);
+		};
+		const { validOptions, optionInfoMap, validOptionInfos, activeKey, setActiveKey, handleKeyDown } = useSelect({
+			options: toRef(props, "data"),
+			inputValue: measureText,
+			filterOption,
+			popupVisible: computedPopupVisible,
+			valueKeys: computedValueKeys,
+			dropdownRef,
+			optionRefs,
+			onSelect: handleSelect,
+			onPopupVisibleChange: handlePopupVisibleChange,
+			enterToOpen: false
+		});
+		const setOptionRef = (key, element) => {
+			const resolved = element && "$el" in element ? element.$el : element;
+			if (resolved instanceof HTMLElement) optionRefs.value[key] = resolved;
+		};
+		const handleOptionClick = (item, event) => {
+			if (!item.disabled) handleSelect(item.key, event);
+		};
+		const handleOptionMouseEnter = (item) => {
+			if (!item.disabled) setActiveKey(item.key);
+		};
+		const handleOptionMouseLeave = (item) => {
+			if (!item.disabled) setActiveKey();
+		};
+		let styleDeclaration;
+		const mirrorStyle = ref();
+		const handleResize = () => {
+			if (styleDeclaration) mirrorStyle.value = getSizeStyles(styleDeclaration);
+		};
+		onMounted(() => {
+			var _inputRef$value;
+			const textareaElement = (_inputRef$value = inputRef.value) === null || _inputRef$value === void 0 ? void 0 : _inputRef$value.textareaRef;
+			if (props.type === "textarea" && textareaElement) {
+				styleDeclaration = window.getComputedStyle(textareaElement);
+				mirrorStyle.value = getSizeStyles(styleDeclaration);
+			}
+		});
+		const mirrorRef = ref();
+		watch(computedPopupVisible, (visible) => {
+			if (props.type === "textarea" && visible) nextTick(() => {
+				var _inputRef$value2, _mirrorRef$value;
+				const textareaElement = (_inputRef$value2 = inputRef.value) === null || _inputRef$value2 === void 0 ? void 0 : _inputRef$value2.textareaRef;
+				if (textareaElement && textareaElement.scrollTop > 0) (_mirrorRef$value = mirrorRef.value) === null || _mirrorRef$value === void 0 || _mirrorRef$value.scrollTo(0, textareaElement.scrollTop);
+			});
+		});
+		const onFocus = (event) => emit("focus", event);
+		const onBlur = (event) => emit("blur", event);
+		const focus = () => {
+			var _inputRef$value3;
+			return (_inputRef$value3 = inputRef.value) === null || _inputRef$value3 === void 0 ? void 0 : _inputRef$value3.focus();
+		};
+		const blur = () => {
+			var _inputRef$value4;
+			return (_inputRef$value4 = inputRef.value) === null || _inputRef$value4 === void 0 ? void 0 : _inputRef$value4.blur();
+		};
+		__expose({
+			inputRef,
+			focus,
+			blur
+		});
+		return (_ctx, _cache) => {
+			var _computedValue$value;
+			return openBlock(), createElementBlock(Fragment, null, [createVNode(unref(DefineDropdown), null, {
+				default: withCtx(() => [createVNode(select_dropdown_default, {
+					ref_key: "dropdownRef",
+					ref: dropdownRef
+				}, {
+					default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(validOptions), (item) => {
+						return openBlock(), createElementBlock("li", {
+							key: item.key,
+							ref_for: true,
+							ref: (element) => setOptionRef(item.key, element),
+							class: normalizeClass([unref(optionPrefixCls), {
+								[`${unref(optionPrefixCls)}-active`]: unref(activeKey) === item.key,
+								[`${unref(optionPrefixCls)}-disabled`]: item.disabled
+							}]),
+							role: "option",
+							"aria-disabled": item.disabled || void 0,
+							onClick: ($event) => handleOptionClick(item, $event),
+							onMouseenter: ($event) => handleOptionMouseEnter(item),
+							onMouseleave: ($event) => handleOptionMouseLeave(item)
+						}, [createElementVNode("span", { class: normalizeClass(`${unref(optionPrefixCls)}-content`) }, [unref(slots).option && item.value ? renderSlot(_ctx.$slots, "option", { data: unref(optionInfoMap).get(item.key) }, void 0, void 0, 0) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createTextVNode(toDisplayString(item.label), 1)], 64))], 2)], 42, _hoisted_1);
+					}), 128))]),
+					_: 3
+				}, 512)]),
+				_: 3
+			}), props.type === "textarea" ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass([unref(prefixCls), {
+					[`${unref(prefixCls)}-fit-width`]: props.fitWidth,
+					[`${unref(prefixCls)}-max-w-full`]: props.maxWFull
+				}])
+			}, [createVNode(resize_observer_default, { onResize: handleResize }, {
+				default: withCtx(() => [createVNode(unref(Textarea), mergeProps({
+					ref_key: "inputRef",
+					ref: inputRef
+				}, unref(attrs), {
+					"allow-clear": unref(mergedAllowClear),
+					"model-value": computedValue.value,
+					disabled: unref(mergedDisabled),
+					readonly: props.readonly,
+					"fit-width": props.fitWidth,
+					"max-w-full": props.maxWFull,
+					onInput: handleInput,
+					onClear: handleClear,
+					onFocus,
+					onBlur,
+					onKeydown: unref(handleKeyDown)
+				}), null, 16, [
+					"allow-clear",
+					"model-value",
+					"disabled",
+					"readonly",
+					"fit-width",
+					"max-w-full",
+					"onKeydown"
+				])]),
+				_: 1
+			}), measureInfo.value.measuring && unref(validOptionInfos).length > 0 ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				ref_key: "mirrorRef",
+				ref: mirrorRef,
+				style: normalizeStyle(mirrorStyle.value),
+				class: normalizeClass(`${unref(prefixCls)}-measure`)
+			}, [createTextVNode(toDisplayString((_computedValue$value = computedValue.value) === null || _computedValue$value === void 0 ? void 0 : _computedValue$value.slice(0, measureInfo.value.location)) + " ", 1), createVNode(unref(Trigger), {
+				trigger: "focus",
+				position: "bl",
+				"popup-offset": 4,
+				"prevent-focus": true,
+				"popup-visible": computedPopupVisible.value,
+				"click-to-close": false,
+				"floating-options": props.floatingOptions,
+				onPopupVisibleChange: handlePopupVisibleChange
+			}, {
+				content: withCtx(() => [createVNode(unref(ReuseDropdown))]),
+				default: withCtx(() => [_cache[0] || (_cache[0] = createElementVNode("span", null, "@", -1))]),
+				_: 1
+			}, 8, ["popup-visible", "floating-options"])], 6)) : createCommentVNode("", true)], 2)) : (openBlock(), createBlock(unref(Trigger), {
+				key: 1,
+				trigger: "focus",
+				position: "bl",
+				"animation-name": "slide-dynamic-origin",
+				"popup-offset": 4,
+				"prevent-focus": true,
+				"popup-visible": computedPopupVisible.value,
+				"click-to-close": false,
+				"floating-options": props.floatingOptions,
+				"auto-fit-popup-width": "",
+				"auto-fit-transform-origin": "",
+				disabled: unref(mergedDisabled),
+				onPopupVisibleChange: handlePopupVisibleChange
+			}, {
+				content: withCtx(() => [createVNode(unref(ReuseDropdown))]),
+				default: withCtx(() => [createVNode(unref(Input), mergeProps({
+					ref_key: "inputRef",
+					ref: inputRef
+				}, unref(attrs), {
+					"allow-clear": unref(mergedAllowClear),
+					"model-value": computedValue.value,
+					disabled: unref(mergedDisabled),
+					readonly: props.readonly,
+					"fit-width": props.fitWidth,
+					"max-w-full": props.maxWFull,
+					"input-attrs": {
+						"role": "combobox",
+						"aria-haspopup": "listbox",
+						"aria-expanded": computedPopupVisible.value,
+						"aria-autocomplete": "list"
+					},
+					onInput: handleInput,
+					onClear: handleClear,
+					onFocus,
+					onBlur,
+					onKeydown: unref(handleKeyDown)
+				}), createSlots({ _: 2 }, [unref(slots).prefix ? {
+					name: "prefix",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "prefix")]),
+					key: "0"
+				} : void 0, unref(slots).suffix ? {
+					name: "suffix",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "suffix")]),
+					key: "1"
+				} : void 0]), 1040, [
+					"allow-clear",
+					"model-value",
+					"disabled",
+					"readonly",
+					"fit-width",
+					"max-w-full",
+					"input-attrs",
+					"onKeydown"
+				])]),
+				_: 3
+			}, 8, [
+				"popup-visible",
+				"floating-options",
+				"disabled"
+			]))], 64);
+		};
+	}
+}));
+//#endregion
+export { mention_vue_vue_type_script_setup_true_lang_default as default };

package/es/menu/base-menu.vue_vue_type_script_setup_true_lang.js

@@ -1,10 +1,10 @@
-import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/objectSpread2.js";
 import { getPrefixCls } from "../_utils/global-config.js";
 import { isNumber, isObject } from "../_utils/is.js";
 import { KEYBOARD_KEY } from "../_utils/keyboard.js";
+import useMergeState from "../_hooks/use-merge-state.js";
 import { omit } from "../_utils/omit.js";
 import usePickSlots from "../_hooks/use-pick-slots.js";
-import useMergeState from "../_hooks/use-merge-state.js";
 import { MenuInjectionKey } from "./context.js";
 import { provideLevel } from "./hooks/use-level.js";
 import useMenuDataCollector from "./hooks/use-menu-data-collector.js";
@@ -265,7 +265,7 @@ var base_menu_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ define
 			else if (backward) target = items[idx < 0 ? 0 : Math.max(idx - 1, 0)];
 			target === null || target === void 0 || target.focus();
 		};
-		provide(MenuInjectionKey, reactive({
+		const menuContext = reactive({
 			theme,
 			mode,
 			levelIndent,
@@ -295,7 +295,8 @@ var base_menu_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ define
 				emit("update:openKeys", newOpenKeys);
 				emit("sub-menu-click", key, newOpenKeys);
 			}
-		}));
+		});
+		provide(MenuInjectionKey, menuContext);
 		provideLevel(1);
 		return (_ctx, _cache) => {
 			return openBlock(), createElementBlock("div", mergeProps({ class: classNames.value }, _ctx.$attrs, { style: computedStyle.value }), [createElementVNode("div", {

package/es/menu/hooks/use-level.js

@@ -2,7 +2,8 @@ import { LevelInjectionKey } from "../context.js";
 import { computed, inject, isRef, provide, reactive } from "vue";
 //#region components/menu/hooks/use-level.ts
 function provideLevel(level) {
-	provide(LevelInjectionKey, reactive({ level: computed(() => isRef(level) ? level.value : level) }));
+	const computedLevel = computed(() => isRef(level) ? level.value : level);
+	provide(LevelInjectionKey, reactive({ level: computedLevel }));
 }
 function useLevel(props) {
 	const { provideNextLevel } = props || {};

package/es/menu/indent.vue_vue_type_script_setup_true_lang.js

@@ -1,4 +1,4 @@
-import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/objectSpread2.js";
 import { getPrefixCls } from "../_utils/global-config.js";
 import useMenuContext from "./hooks/use-menu-context.js";
 import { Fragment, createCommentVNode, createElementBlock, defineComponent, normalizeClass, normalizeStyle, openBlock, renderList, toRef, unref } from "vue";
@@ -11,7 +11,8 @@ var indent_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineCom
 	} },
 	setup(__props) {
 		const prefixCls = getPrefixCls("menu");
-		const levelIndent = toRef(useMenuContext(), "levelIndent");
+		const menuContext = useMenuContext();
+		const levelIndent = toRef(menuContext, "levelIndent");
 		return (_ctx, _cache) => {
 			return __props.level > 1 ? (openBlock(), createElementBlock("span", {
 				key: 0,

package/es/menu/index.d.ts

@@ -1,10 +1,10 @@
 import type { App } from 'vue';
 import type { SDOptions } from '../_utils/types';
 import type { MenuProps } from './interface';
-import _MenuItem from './item';
 import _MenuItemGroup from './item-group.vue';
-import _Menu from './menu';
-import _MenuSubMenu from './sub-menu';
+import _MenuItem from './item.vue';
+import _Menu from './menu.vue';
+import _MenuSubMenu from './sub-menu.vue';
 export type { MenuData, MenuDataItem, MenuEllipsisProps, MenuItemGroupProps, MenuItemProps, MenuMode, MenuProps, MenuTheme, PopupMenuMaxHeightType, SubMenuChildDataType, SubMenuProps, } from './interface';
 export type MenuCollapseTrigger = 'clickTrigger' | 'responsive';
 export type MenuCollapseHandler = (collapsed: boolean, type: MenuCollapseTrigger) => void;

package/es/menu/index.js

@@ -1,6 +1,6 @@
 import { getComponentPrefix, setGlobalConfig } from "../_utils/global-config.js";
-import item_default from "./item.js";
 import item_group_default from "./item-group.js";
+import item_default from "./item.js";
 import sub_menu_default from "./sub-menu.js";
 import menu_default from "./menu.js";
 //#region components/menu/index.ts

package/es/menu/item-group.vue_vue_type_script_setup_true_lang.js

@@ -1,4 +1,4 @@
-import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.142.0/helpers/esm/objectSpread2.js";
 import Ellipsis from "../ellipsis/index.js";
 import useLevel, { provideLevel } from "./hooks/use-level.js";
 import useMenuContext from "./hooks/use-menu-context.js";
@@ -20,7 +20,8 @@ title: { type: String } },
 		* @slot title
 		*/
 		const { level } = useLevel();
-		provideLevel(computed(() => level.value === 1 ? level.value + 1 : level.value));
+		const nextLevel = computed(() => level.value === 1 ? level.value + 1 : level.value);
+		provideLevel(nextLevel);
 		const menuContext = useMenuContext();
 		const prefixCls = computed(() => menuContext.prefixCls);
 		const classNames = computed(() => [`${prefixCls.value}-group`]);

package/es/menu/item.js

@@ -1,129 +1,5 @@
-import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
-import { isActivationKey } from "../_utils/keyboard.js";
-import { omit } from "../_utils/omit.js";
-import Tooltip from "../tooltip/index.js";
-import Ellipsis from "../ellipsis/index.js";
-import useLevel from "./hooks/use-level.js";
-import useMenu from "./hooks/use-menu.js";
-import useMenuContext from "./hooks/use-menu-context.js";
-import { useMenuDataCollectorContext } from "./hooks/use-menu-data-collector.js";
-import indent_default from "./indent.js";
-import { computed, createVNode, defineComponent, isVNode, mergeProps, onMounted, onUnmounted, ref, watch } from "vue";
-import scrollIntoView from "scroll-into-view-if-needed";
-//#region components/menu/item.tsx
-function _isSlot(s) {
-	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
-}
-var item_default = /* @__PURE__ */ defineComponent({
-	name: "MenuItem",
-	inheritAttrs: false,
-	props: { 
-	/**
-	* @zh 是否禁用
-	* @en Whether to disable
-	*/
-disabled: {
-		type: Boolean,
-		default: false
-	} },
-	emits: ["click"],
-	/**
-	* @zh 菜单的图标
-	* @en the icon of menu item
-	* @slot icon
-	* @version 2.11.0
-	*/
-	setup(props, { emit }) {
-		const { key } = useMenu();
-		const { level } = useLevel();
-		const menuContext = useMenuContext();
-		const refItemElement = ref();
-		const isSelected = computed(() => (menuContext.selectedKeys || []).indexOf(key.value) > -1);
-		const menuDataCollector = useMenuDataCollectorContext();
-		onMounted(() => {
-			menuDataCollector === null || menuDataCollector === void 0 || menuDataCollector.collectMenuItem(key.value);
-		});
-		onUnmounted(() => {
-			menuDataCollector === null || menuDataCollector === void 0 || menuDataCollector.removeMenuItem(key.value);
-		});
-		function scrollTo() {
-			if (menuContext.autoScrollIntoView && refItemElement.value && isSelected.value) scrollIntoView(refItemElement.value, _objectSpread2({
-				behavior: "smooth",
-				block: "nearest",
-				scrollMode: "if-needed",
-				boundary: document.documentElement
-			}, menuContext.scrollConfig));
-		}
-		let timer;
-		onMounted(() => {
-			timer = setTimeout(() => {
-				scrollTo();
-			}, 500);
-		});
-		onUnmounted(() => {
-			clearTimeout(timer);
-		});
-		watch([isSelected], () => {
-			scrollTo();
-		});
-		return {
-			menuContext,
-			level,
-			isSelected,
-			refItemElement,
-			onClick(e) {
-				if (props.disabled) return;
-				menuContext.onMenuItemClick && menuContext.onMenuItemClick(key.value);
-				emit("click", e);
-			}
-		};
-	},
-	render() {
-		var _this$$slots$default, _this$$slots;
-		const { level, menuContext, disabled, isSelected, onClick } = this;
-		const { prefixCls, collapsed, inTrigger, mode, tooltipProps } = menuContext;
-		const needTooltip = collapsed && !inTrigger && level === 1;
-		const needTextIndent = mode === "vertical" && level > 1;
-		const children = ((_this$$slots$default = (_this$$slots = this.$slots).default) === null || _this$$slots$default === void 0 ? void 0 : _this$$slots$default.call(_this$$slots)) || [];
-		const showIndent = needTextIndent && !inTrigger && !collapsed;
-		const iconElement = this.$slots.icon && this.$slots.icon();
-		const titleClassNames = [`${prefixCls}-item-inner`, { [`${prefixCls}-title`]: iconElement }];
-		const titleElement = menuContext.ellipsis ? createVNode("span", { "class": [titleClassNames, `${prefixCls}-ellipsis-wrapper`] }, [createVNode(Ellipsis, mergeProps({ "class": `${prefixCls}-ellipsis` }, menuContext.ellipsisProps || {}), _isSlot(children) ? children : { default: () => [children] })]) : showIndent || iconElement ? createVNode("span", { "class": titleClassNames }, [children]) : children;
-		const content = [
-			showIndent && createVNode(indent_default, { "level": level }, null),
-			iconElement && createVNode("span", { "class": `${prefixCls}-icon` }, [iconElement]),
-			titleElement
-		].filter(Boolean);
-		const itemElement = createVNode("div", mergeProps({
-			"ref": "refItemElement",
-			"role": "menuitem",
-			"tabindex": disabled ? void 0 : 0,
-			"aria-disabled": disabled || void 0,
-			"aria-current": isSelected ? "page" : void 0,
-			"class": [`${prefixCls}-item`, {
-				[`${prefixCls}-disabled`]: disabled,
-				[`${prefixCls}-selected`]: isSelected,
-				[`${prefixCls}-has-icon`]: iconElement,
-				[`${prefixCls}-item-indented`]: showIndent
-			}]
-		}, this.$attrs, {
-			"onClick": onClick,
-			"onKeydown": (e) => {
-				if (isActivationKey(e)) {
-					e.preventDefault();
-					onClick(e);
-				}
-			}
-		}), [content, isSelected && mode === "horizontal" && createVNode("div", { "class": `${prefixCls}-selected-label` }, null)]);
-		if (needTooltip) return createVNode(Tooltip, mergeProps({
-			"position": "right",
-			"class": [`${prefixCls}-item-tooltip`, tooltipProps === null || tooltipProps === void 0 ? void 0 : tooltipProps.class].filter(Boolean)
-		}, omit(tooltipProps || {}, ["class"])), {
-			default: () => itemElement,
-			content: () => children
-		});
-		return itemElement;
-	}
-});
+import item_vue_vue_type_script_setup_true_lang_default from "./item.vue_vue_type_script_setup_true_lang.js";
+//#region components/menu/item.vue
+var item_default = item_vue_vue_type_script_setup_true_lang_default;
 //#endregion
 export { item_default as default };

package/es/menu/{item.d.ts → item.vue.d.ts}

@@ -1,4 +1,16 @@
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+declare var __VLS_12: {}, __VLS_20: {}, __VLS_22: {}, __VLS_24: {}, __VLS_38: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_12) => any;
+} & {
+    default?: (props: typeof __VLS_20) => any;
+} & {
+    default?: (props: typeof __VLS_22) => any;
+} & {
+    default?: (props: typeof __VLS_24) => any;
+} & {
+    default?: (props: typeof __VLS_38) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     disabled: {
         type: BooleanConstructor;
         default: boolean;
@@ -17,15 +29,24 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     level: import("vue").ComputedRef<number>;
     isSelected: import("vue").ComputedRef<boolean>;
     refItemElement: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
-    onClick(e: MouseEvent): void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    onClick: (event: MouseEvent) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     disabled: {
         type: BooleanConstructor;
         default: boolean;
     };
 }>> & Readonly<{
-    onClick?: ((...args: any[]) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
 }>, {
     disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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;
+    };
+};