yc-design-vue 1.0.1 → 1.0.3

package/es/Trigger/index.d.ts

@@ -51,7 +51,68 @@ declare const Trigger: {
         preventFocus: boolean;
         scrollToClose: boolean;
         needTransformOrigin: boolean;
-    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, any, any, import('vue').ComponentProvideOptions, {
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        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;
+    }, any, import('vue').ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -154,7 +215,7 @@ declare const Trigger: {
     scrollToClose: boolean;
     needTransformOrigin: boolean;
 }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
-    $slots: any;
+    $slots: Readonly<import('./type').TriggerSlots> & import('./type').TriggerSlots;
 }) & {
     install: (app: App) => void;
 };

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

@@ -1,5 +1,71 @@
-import { TriggerProps } from './type';
-declare function __VLS_template(): any;
+import { TriggerProps, TriggerSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<TriggerSlots> & TriggerSlots;
+    refs: {
+        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;
+    };
+    rootEl: any;
+};
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<TriggerProps, {
     hide(): void;
@@ -49,7 +115,68 @@ declare const __VLS_component: import('vue').DefineComponent<TriggerProps, {
     preventFocus: boolean;
     scrollToClose: boolean;
     needTransformOrigin: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, any, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    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;
+}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/es/Trigger/index.vue.js

@@ -1,7 +1,7 @@
 import _sfc_main from "./index.vue2.js";
 /* empty css           */
 import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Trigger = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-50a0af7f"]]);
+const _Trigger = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-37d87bda"]]);
 export {
   _Trigger as default
 };

package/es/Trigger/index.vue2.js

@@ -1,4 +1,4 @@
-import { defineComponent, ref, useSlots, computed, createElementBlock, openBlock, Fragment, createBlock, resolveDynamicComponent, unref, withModifiers, Teleport, createVNode, Transition, withCtx, withDirectives, createCommentVNode, normalizeStyle, normalizeClass, createElementVNode, renderSlot, vShow } from "vue";
+import { defineComponent, useSlots, ref, computed, createElementBlock, openBlock, Fragment, createBlock, resolveDynamicComponent, unref, withModifiers, Teleport, createVNode, Transition, withCtx, withDirectives, createCommentVNode, normalizeStyle, normalizeClass, createElementVNode, renderSlot, vShow } from "vue";
 import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import "../_shared/utils/time.js";
@@ -64,13 +64,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   },
   emits: ["update:popupVisible", "popup-visible-change", "show", "hide"],
   setup(__props, { expose: __expose, emit: __emit }) {
+    const slots = useSlots();
     const props = __props;
     const emits = __emit;
     const { popupContainer } = getGlobalConfig(props);
     const popupRef = ref();
     const triggerRef = ref();
     const arrowRef = ref();
-    const slots = useSlots();
     const vNode = computed(() => {
       var _a;
       return findFirstLegitChild(((_a = slots.default) == null ? void 0 : _a.call(slots)) || []);

package/es/Trigger/type.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties } from 'vue';
+import { CSSProperties, VNode } from 'vue';
 import { ClassName, PopupContainer } from '../_shared/type';
 export interface TriggerProps {
     popupVisible?: boolean;
@@ -49,8 +49,8 @@ export interface TriggerEmits {
     (e: 'hide'): void;
 }
 export interface TriggerSlots {
-    default(): void;
-    content(): void;
+    default?: () => VNode[];
+    content?: () => VNode[];
 }
 export interface TriggerExpose {
     hide(): void;

package/es/Typography/type.d.ts

@@ -1,4 +1,5 @@
 import { TooltipProps } from '../Tooltip';
+import { VNode } from 'vue';
 export interface TypographyBaseProps {
     tag?: string;
     type?: TypographyType;
@@ -30,16 +31,16 @@ export interface TypographyBaseEmits {
     (e: 'expand', expanded: boolean): void;
 }
 export interface TypographyBaseSlots {
-    default(): void;
-    ['expand-node'](scope: {
+    default?: () => VNode[];
+    'expand-node': (scope: {
         expanded: boolean;
-    }): void;
-    ['copy-icon'](scope: {
+    }) => VNode[];
+    'copy-icon': (scope: {
         copied: boolean;
-    }): void;
-    ['copy-tooltip'](scope: {
+    }) => VNode[];
+    'copy-tooltip': (scope: {
         copied: boolean;
-    }): void;
+    }) => VNode[];
 }
 export interface TypographyParagraphProps {
     blockquote?: boolean;

package/es/Watermark/type.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from 'vue';
 export interface WatermarkProps {
     content?: string | string[];
     image?: string;
@@ -23,5 +24,5 @@ export interface WatermarkFont {
     fontWeight?: 'normal' | 'bold' | 'bolder' | 'lighter' | number;
 }
 export interface WatermarkSlots {
-    default(): void;
+    default?: () => VNode[];
 }

package/es/_shared/type/index.d.ts

@@ -1,4 +1,4 @@
-import { RenderFunction, ComponentPublicInstance, MaybeRef, MaybeRefOrGetter } from 'vue';
+import { RenderFunction } from 'vue';
 export type Size = 'mini' | 'small' | 'medium' | 'large';
 export type Direction = 'vertical' | 'horizontal';
 export type Theme = 'light' | 'dark';
@@ -11,8 +11,3 @@ export type ObjectData = Record<string, any>;
 export type RequiredDeep<T> = {
     [P in keyof T]-?: T[P] extends object ? RequiredDeep<T[P]> : T[P];
 };
-export type VueInstance = ComponentPublicInstance;
-export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
-export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;
-export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
-export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;

package/es/_shared/utils/dom.d.ts

@@ -1,13 +1,13 @@
+import { Ref } from 'vue';
 import { EllipsisConfig } from '../../Typography/type';
 import { BreakpointName, ResponsiveValue } from '../../Grid';
-import { Ref } from 'vue';
 export declare const isServerRendering: boolean;
 export declare const querySelector: (selectors: string, container?: Document | HTMLElement) => HTMLElement | undefined;
 export declare const getElement: (target: string | HTMLElement | undefined, container?: Document | HTMLElement) => HTMLElement | undefined;
-export declare function getDomText(dom: Ref<HTMLElement | undefined>): string;
-export declare function getBreakpointValue(breakpoint: BreakpointName, value: string | number | ResponsiveValue, defaultValue?: number | string): number | string | undefined;
+export declare const getDomText: (dom: Ref<HTMLElement | undefined>) => string;
+export declare const getBreakpointValue: (breakpoint: BreakpointName, value: string | number | ResponsiveValue, defaultValue?: number | string) => number | string | undefined;
 export declare const mediaQueryHandler: (onBreakpoint: (breakpoint: BreakpointName, order: Record<string, number>, index: number) => void, queries?: Record<string, string>) => void;
-export declare function findFirstScrollableParent(element?: HTMLElement): HTMLElement | undefined;
+export declare const findFirstScrollableParent: (element?: HTMLElement) => HTMLElement | undefined;
 /**
  * 计算文本是否需要省略并返回处理后的文本
  * @param originElement 原始DOM元素，用于获取样式
@@ -16,7 +16,7 @@ export declare function findFirstScrollableParent(element?: HTMLElement): HTMLEl
  * @param fullText 完整文本
  * @returns 返回处理后的文本和是否省略的标志
  */
-export declare function calculateEllipsis(originElement: HTMLElement, ellipsisConfig: EllipsisConfig | undefined, operations: (HTMLElement | HTMLElement[] | null) | undefined, fullText: string): {
+export declare const calculateEllipsis: (originElement: HTMLElement, ellipsisConfig: EllipsisConfig | undefined, operations: (HTMLElement | HTMLElement[] | null) | undefined, fullText: string) => {
     tooltip?: {
         type?: "tooltip" | "popover" | undefined;
         props?: Record<string, any> | undefined;

package/es/_shared/utils/dom.js

@@ -1,7 +1,6 @@
-import { isString, isObject, isUndefined } from "./is.js";
-import { useMediaQuery } from "../../node_modules/@vueuse/core/index.js";
 import { watch } from "vue";
-import { unrefElement } from "./vue-utils.js";
+import { unrefElement, useMediaQuery } from "../../node_modules/@vueuse/core/index.js";
+import { isString, isObject, isUndefined } from "./is.js";
 const isServerRendering = (() => {
   try {
     return !(typeof window !== "undefined" && document !== void 0);
@@ -22,10 +21,10 @@ const getElement = (target, container) => {
   }
   return target;
 };
-function getDomText(dom) {
+const getDomText = (dom) => {
   var _a;
   return ((_a = unrefElement(dom)) == null ? void 0 : _a.innerText) || "";
-}
+};
 const getMedicaQueryQuerues = () => {
   return {
     xs: "(min-width: 0)",
@@ -36,7 +35,7 @@ const getMedicaQueryQuerues = () => {
     xxl: "(min-width: 1600px)"
   };
 };
-function getBreakpointValue(breakpoint, value, defaultValue) {
+const getBreakpointValue = (breakpoint, value, defaultValue) => {
   if (!isObject(value)) {
     return value;
   }
@@ -53,7 +52,7 @@ function getBreakpointValue(breakpoint, value, defaultValue) {
     return value[bp];
   }
   return defaultValue;
-}
+};
 const mediaQueryHandler = (onBreakpoint, queries = getMedicaQueryQuerues()) => {
   const breakpoints = [];
   const order = {};
@@ -74,7 +73,7 @@ const mediaQueryHandler = (onBreakpoint, queries = getMedicaQueryQuerues()) => {
     }
   );
 };
-function findFirstScrollableParent(element) {
+const findFirstScrollableParent = (element) => {
   if (!element || element === document.body) {
     return;
   }
@@ -89,7 +88,7 @@ function findFirstScrollableParent(element) {
     }
     currentElement = currentElement.parentElement;
   }
-}
+};
 export {
   findFirstScrollableParent,
   getBreakpointValue,

package/es/_shared/utils/fn.d.ts

@@ -1,8 +1,8 @@
 export declare const sleep: (ms: number) => Promise<unknown>;
-export declare function throttleByRaf(cb: (...args: any[]) => void): {
+export declare const throttleByRaf: (cb: (...args: any[]) => void) => {
     (...args: any[]): void;
     cancel(): void;
 };
-export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number, immediate?: boolean): (...args: Parameters<T>) => void;
-export declare function throttle<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+export declare const debounce: (func: (...args: any) => void, delay: number, immediate?: boolean) => (this: any, ...args: any) => void;
+export declare const throttle: (fn: (...args: any) => void, delay: number) => (this: any, ...args: any) => void;
 export declare const valueToPx: (value: string | number | undefined) => string;

package/es/_shared/utils/fn.js

@@ -6,7 +6,7 @@ const sleep = (ms) => {
     }, ms);
   });
 };
-function throttleByRaf(cb) {
+const throttleByRaf = (cb) => {
   let timer = 0;
   const throttle2 = (...args) => {
     if (timer) {
@@ -22,8 +22,8 @@ function throttleByRaf(cb) {
     timer = 0;
   };
   return throttle2;
-}
-function debounce(func, delay, immediate = false) {
+};
+const debounce = (func, delay, immediate = false) => {
   let timer = null;
   let isInvoked = false;
   return function(...args) {
@@ -40,8 +40,8 @@ function debounce(func, delay, immediate = false) {
       isInvoked = false;
     }, delay);
   };
-}
-function throttle(fn, delay) {
+};
+const throttle = (fn, delay) => {
   let lastTime = 0;
   let timeoutId = null;
   return function(...args) {
@@ -62,7 +62,7 @@ function throttle(fn, delay) {
       }, remaining);
     }
   };
-}
+};
 const valueToPx = (value) => {
   const numberReg = /^-?\d+(\.\d+)?$/;
   if (isNumber(value) || isString(value) && numberReg.test(value)) {

package/es/_shared/utils/global-config.d.ts

@@ -21,8 +21,10 @@ export declare const getGlobalConfig: (props?: Props) => {
     exchangeTime: Ref<any, any>;
     renderEmpty: (name: EmptyComponent) => VNode<import('vue').RendererNode, import('vue').RendererElement, {
         [key: string]: any;
-    }> | (() => void | undefined);
+    }> | (() => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>[] | undefined);
     renderLoading: () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
         [key: string]: any;
-    }> | (() => void);
+    }> | (() => VNode[]);
 };

package/es/_shared/utils/vue-utils.d.ts

@@ -1,7 +1,6 @@
-import { RenderContent, ObjectData, MaybeElement, MaybeComputedElementRef, UnRefElementReturn } from '../type';
+import { RenderContent, ObjectData } from '../type';
 import { VNode } from 'vue';
 export declare const getSlotFunction: (param: RenderContent | undefined) => import('vue').RenderFunction | (() => string | ObjectData[]) | undefined;
 export declare function isVifNode(vnode: VNode | undefined | null): boolean;
 export declare function findFirstLegitChild(node: VNode[] | undefined): VNode | null;
 export declare function findComponentsFromVnodes(vnodes: VNode[], name: string): ObjectData[];
-export declare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T>;

package/es/_shared/utils/vue-utils.js

@@ -1,4 +1,4 @@
-import { isVNode, Fragment, Text, Comment, toValue, h } from "vue";
+import { isVNode, Fragment, Text, Comment, h } from "vue";
 import { isObject, isFunction } from "./is.js";
 const getSlotFunction = (param) => {
   if (param) {
@@ -67,13 +67,8 @@ function findComponentsFromVnodes(vnodes, name) {
   traverse(vnodes);
   return result;
 }
-function unrefElement(elRef) {
-  const plain = toValue(elRef);
-  return (plain == null ? void 0 : plain.$el) ?? plain;
-}
 export {
   findComponentsFromVnodes,
   findFirstLegitChild,
-  getSlotFunction,
-  unrefElement
+  getSlotFunction
 };

package/es/index.d.ts

@@ -68,7 +68,6 @@ import { default as Tabs } from './Tabs';
 import { default as VerificationCode } from './VerificationCode';
 import { default as Watermark } from './Watermark';
 export type { Size, Direction, Theme, TargetContainer, PopupContainer, } from './_shared/type';
-export { Affix, Alert, Anchor, AutoComplete, Avatar, BackTop, Badge, Button, Breadcrumb, Card, Calendar, Carousel, Checkbox, Collapse, ColorPicker, Cascader, Comment, ConfigProvider, Descriptions, Divider, Drawer, Dropdown, Empty, Grid, Icon, Image, Input, InputNumber, InputTag, Layout, Link, List, Menu, Mention, Modal, Message, Notification, OverflowList, PageHeader, Pagination, Popconfirm, Popover, Progress, Radio, Rate, ResizeBox, Result, Scrollbar, Select, Skeleton, Slider, Space, Split, Statistic, Steps, Spin, Switch, Tag, Timeline, Textarea, TimePicker, Tooltip, Transfer, Trigger, Typography, Tabs, VerificationCode, Watermark, };
 export * from './Affix';
 export * from './Alert';
 export * from './Anchor';
@@ -137,6 +136,7 @@ export * from './Typography';
 export * from './Tabs';
 export * from './VerificationCode';
 export * from './Watermark';
+export { Affix, Alert, Anchor, AutoComplete, Avatar, BackTop, Badge, Button, Breadcrumb, Card, Calendar, Carousel, Checkbox, Collapse, ColorPicker, Cascader, Comment, ConfigProvider, Descriptions, Divider, Drawer, Dropdown, Empty, Grid, Icon, Image, Input, InputNumber, InputTag, Layout, Link, List, Menu, Mention, Modal, Message, Notification, OverflowList, PageHeader, Pagination, Popconfirm, Popover, Progress, Radio, Rate, ResizeBox, Result, Scrollbar, Select, Skeleton, Slider, Space, Split, Statistic, Steps, Spin, Switch, Tag, Timeline, Textarea, TimePicker, Tooltip, Transfer, Trigger, Typography, Tabs, VerificationCode, Watermark, };
 export declare const components: Record<string, Plugin>;
 declare const _default: {
     AnchorLink: {
@@ -678,7 +678,70 @@ declare const _default: {
                 $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;
                 }>;
@@ -799,7 +862,7 @@ declare const _default: {
                 show(): void;
                 updatePosition(x: number, y: number): void;
             }> & {} & import('vue').ComponentCustomProperties & {} & {
-                $slots: any;
+                $slots: Readonly<import('./Trigger').TriggerSlots> & import('./Trigger').TriggerSlots;
             }) | null;
             optionRef: ({
                 $: import('vue').ComponentInternalInstance;