yc-design-vue 1.0.2 → 1.0.4

package/es/Input/Input.vue2.js

@@ -8,6 +8,7 @@ import useLimitedInput from "./hooks/useLimitedInput.js";
 import IconButton from "../_shared/components/IconButton.vue.js";
 import _sfc_main$1 from "../_shared/components/PreventFocus.vue.js";
 /* empty css                                         */
+/* empty css                             */
 import InputSuffix from "./InputSuffix.vue.js";
 const _hoisted_1 = ["value", "type", "disabled", "readonly", "placeholder"];
 const _sfc_main = /* @__PURE__ */ defineComponent({

package/es/Input/InputSuffix.vue2.js

@@ -3,7 +3,7 @@ import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import _sfc_main$3 from "../_shared/icons/IconEyeClose.vue2.js";
 import _sfc_main$2 from "../_shared/icons/IconEyeOpen.vue2.js";
 import IconButton from "../_shared/components/IconButton.vue.js";

package/es/Input/hooks/useCursor.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-export default function useCursor(input: Ref<HTMLInputElement | HTMLTextAreaElement | undefined>): {
+declare const _default: (input: Ref<HTMLInputElement | HTMLTextAreaElement | undefined>) => {
     recordCursor: () => void;
     setCursor: () => void;
     getCursor: () => number | undefined;
@@ -17,3 +17,4 @@ export default function useCursor(input: Ref<HTMLInputElement | HTMLTextAreaElem
         afterTxt?: string;
     } | undefined>;
 };
+export default _default;

package/es/Input/hooks/useCursor.js

@@ -1,5 +1,5 @@
 import { ref } from "vue";
-function useCursor(input) {
+const useCursor = (input) => {
   const selectionRef = ref();
   function recordCursor() {
     if (!input.value) return;
@@ -46,7 +46,7 @@ function useCursor(input) {
     getCursor,
     selectionRef
   };
-}
+};
 export {
   useCursor as default
 };

package/es/Input/hooks/useLimitedInput.js

@@ -4,7 +4,7 @@ import "../../_shared/utils/dom.js";
 import { isNumber, isFunction, isUndefined } from "../../_shared/utils/is.js";
 import "../../_shared/utils/time.js";
 import "../../Empty/index.js";
-/* empty css                            */
+/* empty css                                */
 import useControlValue from "../../_shared/utils/control.js";
 import useCursor from "./useCursor.js";
 const useLimitedInput = (params) => {

package/es/Input/type.d.ts

@@ -1,4 +1,5 @@
 import { Size, ObjectData } from '../_shared/type';
+import { VNode } from 'vue';
 export interface InputProps {
     modelValue?: string;
     defaultValue?: string;
@@ -32,11 +33,11 @@ export interface InputEmits {
     (e: 'blur', ev: FocusEvent): void;
 }
 export interface InputSlots {
-    prefix(): void;
-    suffix(): void;
-    prepend(): void;
-    append(): void;
-    label(): void;
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
+    prepend?: () => VNode[];
+    append?: () => VNode[];
+    label?: () => VNode[];
 }
 export interface InputExpose {
     focus(): void;

package/es/InputNumber/InputNumber.vue2.js

@@ -5,7 +5,7 @@ import { sleep } from "../_shared/utils/fn.js";
 import { isString, isFunction, isNumber } from "../_shared/utils/is.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import useControlValue from "../_shared/utils/control.js";
 import OperaBtn from "./InputOperaBtn.vue.js";
 import Input from "../Input/index.js";

package/es/InputNumber/InputOperaBtn.vue2.js

@@ -4,7 +4,7 @@ import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import _sfc_main$2 from "../_shared/icons/IconMinus.vue2.js";
 import _sfc_main$3 from "../_shared/icons/IconPlus.vue.js";
 import Button from "../Button/index.js";

package/es/InputNumber/type.d.ts

@@ -1,4 +1,5 @@
 import { Size, ObjectData } from '../_shared/type';
+import { VNode } from 'vue';
 export interface InputNumberProps {
     modelValue?: InputNumberValue;
     defaultValue?: InputNumberValue;
@@ -30,14 +31,13 @@ export interface InputNumberEmits {
     (e: 'pressEnter', ev: KeyboardEvent): void;
 }
 export interface InputNumberSlots {
-    plus(): void;
-    minus(): void;
-    suffix(): void;
-    prefix(): void;
-    suffix(): void;
-    prepend(): void;
-    append(): void;
-    label(): void;
+    plus?: () => VNode[];
+    minus?: () => VNode[];
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
+    prepend?: () => VNode[];
+    append?: () => VNode[];
+    label?: () => VNode[];
 }
 export interface InputNumberExpose {
     focus(): void;

package/es/InputTag/index.vue2.js

@@ -12,6 +12,7 @@ import Tag from "../Tag/index.js";
 import IconButton from "../_shared/components/IconButton.vue.js";
 import _sfc_main$1 from "../_shared/components/PreventFocus.vue.js";
 /* empty css                                         */
+/* empty css                             */
 const _hoisted_1 = ["disabled", "readonly", "placeholder"];
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{

package/es/InputTag/type.d.ts

@@ -1,5 +1,6 @@
 import { Size, ObjectData } from '../_shared/type';
 import { TagProps } from '../Tag';
+import { VNode } from 'vue';
 export interface InputTagProps {
     modelValue?: InputTagValue;
     defaultValue?: InputTagValue;
@@ -31,11 +32,11 @@ export interface InputTagEmits {
     (e: 'clear', ev: MouseEvent): void;
 }
 export interface InputTagSlots {
-    tag(scope: {
+    tag?: (scope: {
         tag: ObjectData;
-    }): void;
-    prefix(): void;
-    suffix(): void;
+    }) => VNode[];
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
 }
 export interface InputTagExpose {
     focus(): void;

package/es/Layout/Layout.vue.js

@@ -1,7 +1,7 @@
 import _sfc_main from "./Layout.vue2.js";
 /* empty css            */
 import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Layout = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-89d3b476"]]);
+const _Layout = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4f591662"]]);
 export {
   _Layout as default
 };

package/es/Layout/Layout.vue2.js

@@ -1,10 +1,10 @@
-import { defineComponent, toRefs, useSlots, computed, createElementBlock, openBlock, normalizeClass, renderSlot } from "vue";
+import { defineComponent, useSlots, toRefs, computed, createElementBlock, openBlock, normalizeClass, renderSlot } from "vue";
 import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import { isUndefined } from "../_shared/utils/is.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import LayoutSider from "./LayoutSider.vue.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
@@ -15,9 +15,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     hasSider: { type: Boolean, default: void 0 }
   },
   setup(__props) {
+    const slots = useSlots();
     const props = __props;
     const { hasSider: _hasSider } = toRefs(props);
-    const slots = useSlots();
     const hasSider = computed(() => {
       var _a;
       if (!isUndefined(_hasSider.value)) return _hasSider.value;

package/es/Layout/LayoutSider.vue2.js

@@ -4,7 +4,7 @@ import { mediaQueryHandler } from "../_shared/utils/dom.js";
 import { valueToPx } from "../_shared/utils/fn.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import _sfc_main$1 from "../_shared/icons/IconArrowRight.vue.js";
 import useControlValue from "../_shared/utils/control.js";
 import ResizeBox from "../ResizeBox/index.js";

package/es/Layout/type.d.ts

@@ -1,19 +1,20 @@
 import { BreakpointName } from '../Grid';
 import { Theme } from '../_shared/type';
+import { VNode } from 'vue';
 export interface LayoutProps {
     hasSider?: boolean;
 }
 export interface LayoutSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutHeaderSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutContentSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutFooterSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutSiderProps {
     theme?: Theme;
@@ -33,9 +34,9 @@ export interface LayoutSiderEmits {
     (e: 'breakpoint', collapsed: boolean): void;
 }
 export interface LayoutSiderSlots {
-    default(): void;
-    trigger(scope: {
+    default?: () => VNode[];
+    trigger?: (scope: {
         collapsed: boolean;
-    }): void;
+    }) => VNode[];
 }
 export type ResizeDirections = Array<'left' | 'right' | 'top' | 'bottom'>;

package/es/Link/index.vue2.js

@@ -3,7 +3,7 @@ import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import _sfc_main$1 from "../_shared/icons/IconLink.vue.js";
 import Spin from "../Spin/index.js";
 const _hoisted_1 = ["href"];

package/es/Link/type.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from 'vue';
 export interface LinkProps {
     href?: string;
     icon?: boolean;
@@ -12,7 +13,7 @@ export interface LinkEmits {
     (e: 'contextmenu', event: MouseEvent): void;
 }
 export interface LinkSlots {
-    default(): void;
-    icon(): void;
+    default?: () => VNode[];
+    icon?: () => VNode[];
 }
 export type LinkStatus = 'normal' | 'warning' | 'success' | 'danger';

package/es/List/hooks/useScrollReach.js

@@ -5,7 +5,7 @@ import { debounce } from "../../_shared/utils/fn.js";
 import "../../_shared/utils/time.js";
 import "vue";
 import "../../Empty/index.js";
-/* empty css                            */
+/* empty css                                */
 const useScrollReach = (options) => {
   const {
     scrollRef,

package/es/List/type.d.ts

@@ -2,6 +2,7 @@ import { Direction, ObjectData } from '../_shared/type';
 import { GridProps } from '../Grid';
 import { PaginationProps } from '../Pagination';
 import { VirtualListProps } from '../Select';
+import { VNode } from 'vue';
 export interface ListProps {
     data?: ObjectData[];
     size?: ListSize;
@@ -23,32 +24,32 @@ export interface ListEmits {
     (e: 'page-size-change', value: number): void;
 }
 export interface ListSlots {
-    empty(): void;
-    header(): void;
-    footer(): void;
-    default(): void;
-    ['scroll-loading'](): void;
-    item(scope: {
+    empty?: () => VNode[];
+    header?: () => VNode[];
+    footer?: () => VNode[];
+    default?: () => VNode[];
+    'scroll-loading'?: () => VNode[];
+    item?: (scope: {
         index: number;
         item: ObjectData;
-    }): void;
+    }) => VNode[];
 }
 export interface ListItemProps {
     actionLayout?: Direction;
 }
 export interface ListItemSlots {
-    default(): void;
-    meta(): void;
-    extra(): void;
-    actions(): void;
+    default?: () => VNode[];
+    meta?: () => VNode[];
+    extra?: () => VNode[];
+    actions?: () => VNode[];
 }
 export interface ListItemMetaProps {
     title?: string;
     description?: string;
 }
 export interface ListItemMetaSlots {
-    avatar(): void;
-    title(): void;
-    description(): void;
+    avatar?: () => VNode[];
+    title?: () => VNode[];
+    description?: () => VNode[];
 }
 export type ListSize = 'small' | 'medium' | 'large';

package/es/Mention/index.d.ts

@@ -182,7 +182,70 @@ declare const Mention: {
                             $attrs: {
                                 [x: string]: unknown;
                             };
-                            $refs: any;
+                            $refs: {
+                                [x: string]: unknown;
+                            } & {
+                                triggerRef: unknown;
+                                popupRef: ({
+                                    $: import('vue').ComponentInternalInstance;
+                                    $data: {};
+                                    $props: {
+                                        readonly preventFocus?: boolean | undefined;
+                                        readonly tag?: string | undefined;
+                                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                                    $attrs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $refs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $slots: Readonly<{
+                                        [name: string]: import('vue').Slot<any> | undefined;
+                                    }>;
+                                    $root: import('vue').ComponentPublicInstance | null;
+                                    $parent: import('vue').ComponentPublicInstance | null;
+                                    $host: Element | null;
+                                    $emit: (event: string, ...args: any[]) => void;
+                                    $el: any;
+                                    $options: import('vue').ComponentOptionsBase<Readonly<{
+                                        preventFocus?: boolean;
+                                        tag?: string;
+                                    }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                                        preventFocus: boolean;
+                                        tag: string;
+                                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                                        beforeCreate?: (() => void) | (() => void)[];
+                                        created?: (() => void) | (() => void)[];
+                                        beforeMount?: (() => void) | (() => void)[];
+                                        mounted?: (() => void) | (() => void)[];
+                                        beforeUpdate?: (() => void) | (() => void)[];
+                                        updated?: (() => void) | (() => void)[];
+                                        activated?: (() => void) | (() => void)[];
+                                        deactivated?: (() => void) | (() => void)[];
+                                        beforeDestroy?: (() => void) | (() => void)[];
+                                        beforeUnmount?: (() => void) | (() => void)[];
+                                        destroyed?: (() => void) | (() => void)[];
+                                        unmounted?: (() => void) | (() => void)[];
+                                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                                    };
+                                    $forceUpdate: () => void;
+                                    $nextTick: typeof import('vue').nextTick;
+                                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                                } & Readonly<{
+                                    preventFocus: boolean;
+                                    tag: string;
+                                }> & Omit<Readonly<{
+                                    preventFocus?: boolean;
+                                    tag?: string;
+                                }> & Readonly<{}>, "preventFocus" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                                    $slots: {
+                                        default?(_: {}): any;
+                                    };
+                                }) | null;
+                                arrowRef: HTMLDivElement;
+                            };
                             $slots: Readonly<{
                                 [name: string]: import('vue').Slot<any> | undefined;
                             }>;
@@ -303,7 +366,7 @@ declare const Mention: {
                             show(): void;
                             updatePosition(x: number, y: number): void;
                         }> & {} & import('vue').ComponentCustomProperties & {} & {
-                            $slots: any;
+                            $slots: Readonly<import('..').TriggerSlots> & import('..').TriggerSlots;
                         }) | null;
                         inputRef: ({
                             $: import('vue').ComponentInternalInstance;

package/es/Mention/index.vue.d.ts

@@ -153,7 +153,70 @@ declare function __VLS_template(): {
                             $attrs: {
                                 [x: string]: unknown;
                             };
-                            $refs: any;
+                            $refs: {
+                                [x: string]: unknown;
+                            } & {
+                                triggerRef: unknown;
+                                popupRef: ({
+                                    $: import('vue').ComponentInternalInstance;
+                                    $data: {};
+                                    $props: {
+                                        readonly preventFocus?: boolean | undefined;
+                                        readonly tag?: string | undefined;
+                                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                                    $attrs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $refs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $slots: Readonly<{
+                                        [name: string]: import('vue').Slot<any> | undefined;
+                                    }>;
+                                    $root: import('vue').ComponentPublicInstance | null;
+                                    $parent: import('vue').ComponentPublicInstance | null;
+                                    $host: Element | null;
+                                    $emit: (event: string, ...args: any[]) => void;
+                                    $el: any;
+                                    $options: import('vue').ComponentOptionsBase<Readonly<{
+                                        preventFocus?: boolean;
+                                        tag?: string;
+                                    }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                                        preventFocus: boolean;
+                                        tag: string;
+                                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                                        beforeCreate?: (() => void) | (() => void)[];
+                                        created?: (() => void) | (() => void)[];
+                                        beforeMount?: (() => void) | (() => void)[];
+                                        mounted?: (() => void) | (() => void)[];
+                                        beforeUpdate?: (() => void) | (() => void)[];
+                                        updated?: (() => void) | (() => void)[];
+                                        activated?: (() => void) | (() => void)[];
+                                        deactivated?: (() => void) | (() => void)[];
+                                        beforeDestroy?: (() => void) | (() => void)[];
+                                        beforeUnmount?: (() => void) | (() => void)[];
+                                        destroyed?: (() => void) | (() => void)[];
+                                        unmounted?: (() => void) | (() => void)[];
+                                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                                    };
+                                    $forceUpdate: () => void;
+                                    $nextTick: typeof nextTick;
+                                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                                } & Readonly<{
+                                    preventFocus: boolean;
+                                    tag: string;
+                                }> & Omit<Readonly<{
+                                    preventFocus?: boolean;
+                                    tag?: string;
+                                }> & Readonly<{}>, "preventFocus" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                                    $slots: {
+                                        default?(_: {}): any;
+                                    };
+                                }) | null;
+                                arrowRef: HTMLDivElement;
+                            };
                             $slots: Readonly<{
                                 [name: string]: import('vue').Slot<any> | undefined;
                             }>;
@@ -274,7 +337,7 @@ declare function __VLS_template(): {
                             show(): void;
                             updatePosition(x: number, y: number): void;
                         }> & {} & import('vue').ComponentCustomProperties & {} & {
-                            $slots: any;
+                            $slots: Readonly<import('..').TriggerSlots> & import('..').TriggerSlots;
                         }) | null;
                         inputRef: ({
                             $: import('vue').ComponentInternalInstance;
@@ -931,7 +994,70 @@ declare const __VLS_component: import('vue').DefineComponent<MentionProps, {
                         $attrs: {
                             [x: string]: unknown;
                         };
-                        $refs: any;
+                        $refs: {
+                            [x: string]: unknown;
+                        } & {
+                            triggerRef: unknown;
+                            popupRef: ({
+                                $: import('vue').ComponentInternalInstance;
+                                $data: {};
+                                $props: {
+                                    readonly preventFocus?: boolean | undefined;
+                                    readonly tag?: string | undefined;
+                                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                                $attrs: {
+                                    [x: string]: unknown;
+                                };
+                                $refs: {
+                                    [x: string]: unknown;
+                                };
+                                $slots: Readonly<{
+                                    [name: string]: import('vue').Slot<any> | undefined;
+                                }>;
+                                $root: import('vue').ComponentPublicInstance | null;
+                                $parent: import('vue').ComponentPublicInstance | null;
+                                $host: Element | null;
+                                $emit: (event: string, ...args: any[]) => void;
+                                $el: any;
+                                $options: import('vue').ComponentOptionsBase<Readonly<{
+                                    preventFocus?: boolean;
+                                    tag?: string;
+                                }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                                    preventFocus: boolean;
+                                    tag: string;
+                                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                                    beforeCreate?: (() => void) | (() => void)[];
+                                    created?: (() => void) | (() => void)[];
+                                    beforeMount?: (() => void) | (() => void)[];
+                                    mounted?: (() => void) | (() => void)[];
+                                    beforeUpdate?: (() => void) | (() => void)[];
+                                    updated?: (() => void) | (() => void)[];
+                                    activated?: (() => void) | (() => void)[];
+                                    deactivated?: (() => void) | (() => void)[];
+                                    beforeDestroy?: (() => void) | (() => void)[];
+                                    beforeUnmount?: (() => void) | (() => void)[];
+                                    destroyed?: (() => void) | (() => void)[];
+                                    unmounted?: (() => void) | (() => void)[];
+                                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                                };
+                                $forceUpdate: () => void;
+                                $nextTick: typeof nextTick;
+                                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                            } & Readonly<{
+                                preventFocus: boolean;
+                                tag: string;
+                            }> & Omit<Readonly<{
+                                preventFocus?: boolean;
+                                tag?: string;
+                            }> & Readonly<{}>, "preventFocus" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                                $slots: {
+                                    default?(_: {}): any;
+                                };
+                            }) | null;
+                            arrowRef: HTMLDivElement;
+                        };
                         $slots: Readonly<{
                             [name: string]: import('vue').Slot<any> | undefined;
                         }>;
@@ -1052,7 +1178,7 @@ declare const __VLS_component: import('vue').DefineComponent<MentionProps, {
                         show(): void;
                         updatePosition(x: number, y: number): void;
                     }> & {} & import('vue').ComponentCustomProperties & {} & {
-                        $slots: any;
+                        $slots: Readonly<import('..').TriggerSlots> & import('..').TriggerSlots;
                     }) | null;
                     inputRef: ({
                         $: import('vue').ComponentInternalInstance;

package/es/Mention/index.vue.js

@@ -4,7 +4,7 @@ import "../_shared/utils/dom.js";
 import { isArray, isNull } from "../_shared/utils/is.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import useControlValue from "../_shared/utils/control.js";
 import useCursor from "../Input/hooks/useCursor.js";
 import AutoComplete from "../AutoComplete/index.js";

package/es/Mention/type.d.ts

@@ -1,5 +1,6 @@
 import { SelectOptions, SelectValue } from '../Select';
 import { ObjectData } from '../_shared/type';
+import { VNode } from 'vue';
 export interface MentionProps {
     modelValue?: string;
     defaultValue?: string;
@@ -25,7 +26,7 @@ export interface MentionExpose {
     blur(): void;
 }
 export interface MentionSlots {
-    option(scope: {
+    option?: (scope: {
         data: ObjectData;
-    }): void;
+    }) => VNode[];
 }

package/es/Menu/Menu.vue2.js

@@ -3,7 +3,7 @@ import "../node_modules/tinycolor2/esm/tinycolor.js";
 import { mediaQueryHandler } from "../_shared/utils/dom.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import _sfc_main$1 from "../_shared/icons/IconMenuFold.vue.js";
 import _sfc_main$2 from "../_shared/icons/IconMenuUnfold.vue.js";
 import useContext from "./hooks/useContext.js";

package/es/Menu/MenuEllipsis.vue2.js

@@ -4,7 +4,7 @@ import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import "../_shared/utils/time.js";
 import "../Empty/index.js";
-/* empty css                         */
+/* empty css                             */
 import _sfc_main$1 from "../_shared/icons/IconMore.vue.js";
 import useContext, { isMenuItemActive } from "./hooks/useContext.js";
 import _sfc_main$3 from "./MenuPopOption.vue.js";