naive-ui 2.23.2 → 2.24.3

package/es/auto-complete/src/AutoComplete.d.ts

@@ -1,9 +1,10 @@
 import { PropType, InputHTMLAttributes } from 'vue';
 import { TreeNode } from 'treemate';
+import { RenderOption, RenderLabel } from '../../_internal/select-menu/src/interface';
 import { MaybeArray } from '../../_utils';
 import type { ExtractPublicPropTypes } from '../../_utils';
 import type { SelectBaseOption, SelectGroupOption, SelectIgnoredOption } from '../../select/src/interface';
-import { AutoCompleteOptions, OnUpdateValue, OnSelect } from './interface';
+import type { AutoCompleteOptions, OnUpdateValue, OnSelect } from './interface';
 declare const autoCompleteProps: {
     readonly to: {
         type: PropType<string | boolean | HTMLElement>;
@@ -35,6 +36,8 @@ declare const autoCompleteProps: {
     readonly clearAfterSelect: BooleanConstructor;
     readonly getShow: PropType<(inputValue: string) => boolean>;
     readonly inputProps: PropType<InputHTMLAttributes>;
+    readonly renderOption: PropType<RenderOption>;
+    readonly renderLabel: PropType<RenderLabel>;
     readonly size: PropType<"small" | "medium" | "large">;
     readonly options: {
         readonly type: PropType<AutoCompleteOptions>;
@@ -46,11 +49,7 @@ declare const autoCompleteProps: {
     readonly onSelect: PropType<MaybeArray<OnSelect>>;
     readonly onBlur: PropType<MaybeArray<(e: FocusEvent) => void>>;
     readonly onFocus: PropType<MaybeArray<(e: FocusEvent) => void>>;
-    readonly onInput: {
-        readonly type: PropType<MaybeArray<OnUpdateValue> | undefined>;
-        readonly validator: () => boolean;
-        readonly default: undefined;
-    };
+    readonly onInput: PropType<MaybeArray<OnUpdateValue> | undefined>;
     readonly theme: PropType<import("../../_mixins").Theme<"AutoComplete", {
         menuBoxShadow: string;
     }, {
@@ -432,6 +431,8 @@ declare const _default: import("vue").DefineComponent<{
     readonly clearAfterSelect: BooleanConstructor;
     readonly getShow: PropType<(inputValue: string) => boolean>;
     readonly inputProps: PropType<InputHTMLAttributes>;
+    readonly renderOption: PropType<RenderOption>;
+    readonly renderLabel: PropType<RenderLabel>;
     readonly size: PropType<"small" | "medium" | "large">;
     readonly options: {
         readonly type: PropType<AutoCompleteOptions>;
@@ -443,11 +444,7 @@ declare const _default: import("vue").DefineComponent<{
     readonly onSelect: PropType<MaybeArray<OnSelect>>;
     readonly onBlur: PropType<MaybeArray<(e: FocusEvent) => void>>;
     readonly onFocus: PropType<MaybeArray<(e: FocusEvent) => void>>;
-    readonly onInput: {
-        readonly type: PropType<MaybeArray<OnUpdateValue> | undefined>;
-        readonly validator: () => boolean;
-        readonly default: undefined;
-    };
+    readonly onInput: PropType<MaybeArray<OnUpdateValue> | undefined>;
     readonly theme: PropType<import("../../_mixins").Theme<"AutoComplete", {
         menuBoxShadow: string;
     }, {
@@ -1078,48 +1075,52 @@ declare const _default: import("vue").DefineComponent<{
     mergedBordered: import("vue").ComputedRef<boolean>;
     namespace: import("vue").ComputedRef<string | undefined>;
     mergedClsPrefix: import("vue").ComputedRef<string>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    readonly to?: unknown;
-    readonly bordered?: unknown;
-    readonly clearable?: unknown;
-    readonly defaultValue?: unknown;
-    readonly loading?: unknown;
-    readonly disabled?: unknown;
-    readonly placeholder?: unknown;
-    readonly value?: unknown;
-    readonly blurAfterSelect?: unknown;
-    readonly clearAfterSelect?: unknown;
-    readonly getShow?: unknown;
-    readonly inputProps?: unknown;
-    readonly size?: unknown;
-    readonly options?: unknown;
-    readonly zIndex?: unknown;
-    readonly 'onUpdate:value'?: unknown;
-    readonly onUpdateValue?: unknown;
-    readonly onSelect?: unknown;
-    readonly onBlur?: unknown;
-    readonly onFocus?: unknown;
-    readonly onInput?: unknown;
-    readonly theme?: unknown;
-    readonly themeOverrides?: unknown;
-    readonly builtinThemeOverrides?: unknown;
-} & {
-    options: AutoCompleteOptions;
-    defaultValue: string | null;
-    blurAfterSelect: boolean;
-    clearAfterSelect: boolean;
-} & {
-    value?: string | undefined;
-    size?: "small" | "medium" | "large" | undefined;
-    zIndex?: number | undefined;
-    disabled?: boolean | undefined;
-    onFocus?: MaybeArray<(e: FocusEvent) => void> | undefined;
-    onBlur?: MaybeArray<(e: FocusEvent) => void> | undefined;
-    onInput?: MaybeArray<OnUpdateValue> | undefined;
-    onSelect?: MaybeArray<OnSelect> | undefined;
-    placeholder?: string | undefined;
-    to?: string | boolean | HTMLElement | undefined;
-    theme?: import("../../_mixins").Theme<"AutoComplete", {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly to: {
+        type: PropType<string | boolean | HTMLElement>;
+        default: undefined;
+    };
+    readonly bordered: {
+        readonly type: PropType<boolean | undefined>;
+        readonly default: undefined;
+    };
+    readonly clearable: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly defaultValue: {
+        readonly type: PropType<string | null>;
+        readonly default: null;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly disabled: {
+        readonly type: PropType<boolean | undefined>;
+        readonly default: undefined;
+    };
+    readonly placeholder: StringConstructor;
+    readonly value: StringConstructor;
+    readonly blurAfterSelect: BooleanConstructor;
+    readonly clearAfterSelect: BooleanConstructor;
+    readonly getShow: PropType<(inputValue: string) => boolean>;
+    readonly inputProps: PropType<InputHTMLAttributes>;
+    readonly renderOption: PropType<RenderOption>;
+    readonly renderLabel: PropType<RenderLabel>;
+    readonly size: PropType<"small" | "medium" | "large">;
+    readonly options: {
+        readonly type: PropType<AutoCompleteOptions>;
+        readonly default: () => never[];
+    };
+    readonly zIndex: NumberConstructor;
+    readonly 'onUpdate:value': PropType<MaybeArray<OnUpdateValue>>;
+    readonly onUpdateValue: PropType<MaybeArray<OnUpdateValue>>;
+    readonly onSelect: PropType<MaybeArray<OnSelect>>;
+    readonly onBlur: PropType<MaybeArray<(e: FocusEvent) => void>>;
+    readonly onFocus: PropType<MaybeArray<(e: FocusEvent) => void>>;
+    readonly onInput: PropType<MaybeArray<OnUpdateValue> | undefined>;
+    readonly theme: PropType<import("../../_mixins").Theme<"AutoComplete", {
         menuBoxShadow: string;
     }, {
         InternalSelectMenu: import("../../_mixins").Theme<"InternalSelectMenu", {
@@ -1234,8 +1235,8 @@ declare const _default: import("vue").DefineComponent<{
             paddingLarge: string;
             clearSize: string;
         }, any>;
-    }> | undefined;
-    themeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"AutoComplete", {
+    }>>;
+    readonly themeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"AutoComplete", {
         menuBoxShadow: string;
     }, {
         InternalSelectMenu: import("../../_mixins").Theme<"InternalSelectMenu", {
@@ -1350,8 +1351,8 @@ declare const _default: import("vue").DefineComponent<{
             paddingLarge: string;
             clearSize: string;
         }, any>;
-    }>> | undefined;
-    builtinThemeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"AutoComplete", {
+    }>>>;
+    readonly builtinThemeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"AutoComplete", {
         menuBoxShadow: string;
     }, {
         InternalSelectMenu: import("../../_mixins").Theme<"InternalSelectMenu", {
@@ -1466,17 +1467,9 @@ declare const _default: import("vue").DefineComponent<{
             paddingLarge: string;
             clearSize: string;
         }, any>;
-    }>> | undefined;
-    loading?: boolean | undefined;
-    bordered?: boolean | undefined;
-    clearable?: boolean | undefined;
-    inputProps?: InputHTMLAttributes | undefined;
-    "onUpdate:value"?: MaybeArray<OnUpdateValue> | undefined;
-    onUpdateValue?: MaybeArray<OnUpdateValue> | undefined;
-    getShow?: ((inputValue: string) => boolean) | undefined;
-}>, {
+    }>>>;
+}>>, {
     disabled: boolean | undefined;
-    onInput: MaybeArray<OnUpdateValue> | undefined;
     to: string | boolean | HTMLElement;
     loading: boolean;
     bordered: boolean | undefined;

package/es/auto-complete/src/AutoComplete.js

@@ -1,16 +1,16 @@
-import { h, ref, toRef, computed, defineComponent, Transition, withDirectives } from 'vue';
+import { h, ref, toRef, computed, defineComponent, Transition, withDirectives, watchEffect } from 'vue';
 import { createTreeMate } from 'treemate';
 import { VBinder, VTarget, VFollower } from 'vueuc';
 import { clickoutside } from 'vdirs';
 import { useIsMounted, useMergedState } from 'vooks';
+import { tmOptions } from '../../select/src/utils';
 import { useFormItem, useTheme, useConfig } from '../../_mixins';
-import { call, warn, useAdjustedTo, getFirstSlotVNode } from '../../_utils';
+import { call, useAdjustedTo, getFirstSlotVNode, warnOnce } from '../../_utils';
 import { NInternalSelectMenu } from '../../_internal';
 import { NInput } from '../../input';
 import { autoCompleteLight } from '../styles';
 import { mapAutoCompleteOptionsToSelectOptions } from './utils';
 import style from './styles/index.cssr';
-import { tmOptions } from '../../select/src/utils';
 const autoCompleteProps = Object.assign(Object.assign({}, useTheme.props), { to: useAdjustedTo.propTo, bordered: {
         type: Boolean,
         default: undefined
@@ -26,25 +26,23 @@ const autoCompleteProps = Object.assign(Object.assign({}, useTheme.props), { to:
     }, disabled: {
         type: Boolean,
         default: undefined
-    }, placeholder: String, value: String, blurAfterSelect: Boolean, clearAfterSelect: Boolean, getShow: Function, inputProps: Object, size: String, options: {
+    }, placeholder: String, value: String, blurAfterSelect: Boolean, clearAfterSelect: Boolean, getShow: Function, inputProps: Object, renderOption: Function, renderLabel: Function, size: String, options: {
         type: Array,
         default: () => []
     }, zIndex: Number, 'onUpdate:value': [Function, Array], onUpdateValue: [Function, Array], onSelect: [Function, Array], onBlur: [Function, Array], onFocus: [Function, Array], 
     // deprecated
-    onInput: {
-        type: [Function, Array],
-        validator: () => {
-            if (process.env.NODE_ENV !== 'production') {
-                warn('auto-complete', '`on-input` is deprecated, please use `on-update:value` instead.');
-            }
-            return true;
-        },
-        default: undefined
-    } });
+    onInput: [Function, Array] });
 export default defineComponent({
     name: 'AutoComplete',
     props: autoCompleteProps,
     setup(props) {
+        if (process.env.NODE_ENV !== 'production') {
+            watchEffect(() => {
+                if (props.onInput !== undefined) {
+                    warnOnce('auto-complete', '`on-input` is deprecated, please use `on-update:value` instead.');
+                }
+            });
+        }
         const { mergedBorderedRef, namespaceRef, mergedClsPrefixRef } = useConfig(props);
         const formItem = useFormItem(props);
         const { mergedSizeRef, mergedDisabledRef } = formItem;
@@ -242,7 +240,7 @@ export default defineComponent({
                         default: () => (h(Transition, { name: "fade-in-scale-up-transition", appear: this.isMounted }, {
                             default: () => this.active
                                 ? withDirectives(h(NInternalSelectMenu, { clsPrefix: mergedClsPrefix, ref: "menuInstRef", theme: this.mergedTheme.peers.InternalSelectMenu, themeOverrides: this.mergedTheme.peerOverrides
-                                        .InternalSelectMenu, "auto-pending": true, class: `${mergedClsPrefix}-auto-complete-menu`, style: this.cssVars, treeMate: this.treeMate, multiple: false, size: "medium", onToggle: this.handleToggle }), [[clickoutside, this.handleClickOutsideMenu]])
+                                        .InternalSelectMenu, "auto-pending": true, class: `${mergedClsPrefix}-auto-complete-menu`, style: this.cssVars, treeMate: this.treeMate, multiple: false, renderLabel: this.renderLabel, renderOption: this.renderOption, size: "medium", onToggle: this.handleToggle }), [[clickoutside, this.handleClickOutsideMenu]])
                                 : null
                         }))
                     })

package/es/avatar/src/Avatar.d.ts

@@ -139,28 +139,27 @@ declare const _default: import("vue").DefineComponent<{
     }>;
     hasLoadError: import("vue").Ref<boolean>;
     handleError: (e: Event) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    readonly size?: unknown;
-    readonly src?: unknown;
-    readonly circle?: unknown;
-    readonly objectFit?: unknown;
-    readonly round?: unknown;
-    readonly bordered?: unknown;
-    readonly onError?: unknown;
-    readonly fallbackSrc?: unknown;
-    readonly color?: unknown;
-    readonly theme?: unknown;
-    readonly themeOverrides?: unknown;
-    readonly builtinThemeOverrides?: unknown;
-} & {} & {
-    onError?: ((e: Event) => void) | undefined;
-    color?: string | undefined;
-    round?: boolean | undefined;
-    size?: Size | undefined;
-    circle?: boolean | undefined;
-    objectFit?: ObjectFit | undefined;
-    src?: string | undefined;
-    theme?: import("../../_mixins").Theme<"Avatar", {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly size: PropType<Size>;
+    readonly src: StringConstructor;
+    readonly circle: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly objectFit: PropType<ObjectFit>;
+    readonly round: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly bordered: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly onError: PropType<(e: Event) => void>;
+    readonly fallbackSrc: StringConstructor;
+    /** @deprecated */
+    readonly color: StringConstructor;
+    readonly theme: PropType<import("../../_mixins").Theme<"Avatar", {
         borderRadius: string;
         fontSize: string;
         border: string;
@@ -172,8 +171,8 @@ declare const _default: import("vue").DefineComponent<{
         color: string;
         colorModal: string;
         colorPopover: string;
-    }, any> | undefined;
-    themeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Avatar", {
+    }, any>>;
+    readonly themeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Avatar", {
         borderRadius: string;
         fontSize: string;
         border: string;
@@ -185,8 +184,8 @@ declare const _default: import("vue").DefineComponent<{
         color: string;
         colorModal: string;
         colorPopover: string;
-    }, any>> | undefined;
-    builtinThemeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Avatar", {
+    }, any>>>;
+    readonly builtinThemeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"Avatar", {
         borderRadius: string;
         fontSize: string;
         border: string;
@@ -198,10 +197,8 @@ declare const _default: import("vue").DefineComponent<{
         color: string;
         colorModal: string;
         colorPopover: string;
-    }, any>> | undefined;
-    bordered?: boolean | undefined;
-    fallbackSrc?: string | undefined;
-}>, {
+    }, any>>>;
+}>>, {
     round: boolean;
     circle: boolean;
     bordered: boolean;

package/es/avatar/src/AvatarGroup.d.ts

@@ -1,13 +1,13 @@
-import { PropType, CSSProperties, InjectionKey } from 'vue';
+import { PropType, CSSProperties } from 'vue';
 import type { Size } from './interface';
-import type { ExtractPublicPropTypes } from '../../_utils';
+import { ExtractPublicPropTypes } from '../../_utils';
 export interface AvatarGroupInjection {
     size?: Size | undefined;
 }
 interface AvatarOption {
     src: string;
 }
-export declare const avatarGroupInjectionKey: InjectionKey<AvatarGroupInjection>;
+export declare const avatarGroupInjectionKey: import("vue").InjectionKey<AvatarGroupInjection>;
 declare const avatarGroupProps: {
     readonly max: NumberConstructor;
     readonly maxStyle: PropType<string | CSSProperties>;
@@ -32,20 +32,16 @@ declare const _default: import("vue").DefineComponent<{
     mergedClsPrefix: import("vue").ComputedRef<string>;
     restOptions: import("vue").ComputedRef<AvatarOption[] | undefined>;
     displayedOptions: import("vue").ComputedRef<AvatarOption[]>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    readonly max?: unknown;
-    readonly maxStyle?: unknown;
-    readonly options?: unknown;
-    readonly vertical?: unknown;
-    readonly size?: unknown;
-} & {
-    vertical: boolean;
-    options: AvatarOption[];
-} & {
-    size?: Size | undefined;
-    max?: number | undefined;
-    maxStyle?: string | CSSProperties | undefined;
-}>, {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly max: NumberConstructor;
+    readonly maxStyle: PropType<string | CSSProperties>;
+    readonly options: {
+        readonly type: PropType<AvatarOption[]>;
+        readonly default: () => never[];
+    };
+    readonly vertical: BooleanConstructor;
+    readonly size: PropType<Size | undefined>;
+}>>, {
     vertical: boolean;
     options: AvatarOption[];
 }>;

package/es/avatar/src/AvatarGroup.js

@@ -1,8 +1,9 @@
 import { h, defineComponent, provide, computed } from 'vue';
 import NAvatar from './Avatar';
 import { useConfig, useStyle } from '../../_mixins';
+import { createInjectionKey } from '../../_utils';
 import style from './styles/avatar-group.cssr';
-export const avatarGroupInjectionKey = Symbol('avatar-group');
+export const avatarGroupInjectionKey = createInjectionKey('n-avatar-group');
 const avatarGroupProps = {
     max: Number,
     maxStyle: [Object, String],
@@ -25,7 +26,9 @@ export default defineComponent({
             if (max === undefined)
                 return undefined;
             const { options } = props;
-            return options.slice(max, options.length);
+            if (options.length > max)
+                return options.slice(max - 1, options.length);
+            return [];
         });
         const displayedOptionsRef = computed(() => {
             const { options, max } = props;

package/es/back-top/src/BackTop.d.ts

@@ -21,7 +21,7 @@ declare const backTopProps: {
         readonly type: NumberConstructor;
         readonly default: 180;
     };
-    readonly listenTo: PropType<string | HTMLElement | (() => HTMLElement)>;
+    readonly listenTo: PropType<string | HTMLElement | Document | (() => HTMLElement | Document)>;
     readonly 'onUpdate:show': {
         readonly type: FunctionConstructor;
         readonly default: () => void;
@@ -106,7 +106,7 @@ declare const _default: import("vue").DefineComponent<{
         readonly type: NumberConstructor;
         readonly default: 180;
     };
-    readonly listenTo: PropType<string | HTMLElement | (() => HTMLElement)>;
+    readonly listenTo: PropType<string | HTMLElement | Document | (() => HTMLElement | Document)>;
     readonly 'onUpdate:show': {
         readonly type: FunctionConstructor;
         readonly default: () => void;
@@ -199,30 +199,48 @@ declare const _default: import("vue").DefineComponent<{
         '--n-icon-color-pressed': string;
         '--n-text-color': string;
     }>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
-    readonly show?: unknown;
-    readonly right?: unknown;
-    readonly bottom?: unknown;
-    readonly to?: unknown;
-    readonly visibilityHeight?: unknown;
-    readonly listenTo?: unknown;
-    readonly 'onUpdate:show'?: unknown;
-    readonly target?: unknown;
-    readonly onShow?: unknown;
-    readonly onHide?: unknown;
-    readonly theme?: unknown;
-    readonly themeOverrides?: unknown;
-    readonly builtinThemeOverrides?: unknown;
-} & {
-    right: string | number;
-    bottom: string | number;
-    to: string | HTMLElement;
-    "onUpdate:show": Function;
-    visibilityHeight: number;
-} & {
-    show?: boolean | undefined;
-    target?: (() => HTMLElement | undefined) | undefined;
-    theme?: import("../../_mixins").Theme<"BackTop", {
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly show: {
+        readonly type: PropType<boolean | undefined>;
+        readonly default: undefined;
+    };
+    readonly right: {
+        readonly type: PropType<string | number>;
+        readonly default: 40;
+    };
+    readonly bottom: {
+        readonly type: PropType<string | number>;
+        readonly default: 40;
+    };
+    readonly to: {
+        readonly type: PropType<string | HTMLElement>;
+        readonly default: "body";
+    };
+    readonly visibilityHeight: {
+        readonly type: NumberConstructor;
+        readonly default: 180;
+    };
+    readonly listenTo: PropType<string | HTMLElement | Document | (() => HTMLElement | Document)>;
+    readonly 'onUpdate:show': {
+        readonly type: FunctionConstructor;
+        readonly default: () => void;
+    };
+    readonly target: {
+        readonly type: PropType<() => HTMLElement | undefined>;
+        readonly validator: () => boolean;
+        readonly default: undefined;
+    };
+    readonly onShow: {
+        readonly type: PropType<(() => void) | undefined>;
+        readonly validator: () => boolean;
+        readonly default: undefined;
+    };
+    readonly onHide: {
+        readonly type: PropType<(() => void) | undefined>;
+        readonly validator: () => boolean;
+        readonly default: undefined;
+    };
+    readonly theme: PropType<import("../../_mixins").Theme<"BackTop", {
         color: string;
         textColor: string;
         iconColor: string;
@@ -235,8 +253,8 @@ declare const _default: import("vue").DefineComponent<{
         height: string;
         borderRadius: string;
         iconSize: string;
-    }, any> | undefined;
-    themeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"BackTop", {
+    }, any>>;
+    readonly themeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"BackTop", {
         color: string;
         textColor: string;
         iconColor: string;
@@ -249,8 +267,8 @@ declare const _default: import("vue").DefineComponent<{
         height: string;
         borderRadius: string;
         iconSize: string;
-    }, any>> | undefined;
-    builtinThemeOverrides?: import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"BackTop", {
+    }, any>>>;
+    readonly builtinThemeOverrides: PropType<import("../../_mixins/use-theme").ExtractThemeOverrides<import("../../_mixins").Theme<"BackTop", {
         color: string;
         textColor: string;
         iconColor: string;
@@ -263,11 +281,8 @@ declare const _default: import("vue").DefineComponent<{
         height: string;
         borderRadius: string;
         iconSize: string;
-    }, any>> | undefined;
-    onShow?: (() => void) | undefined;
-    onHide?: (() => void) | undefined;
-    listenTo?: string | HTMLElement | (() => HTMLElement) | undefined;
-}>, {
+    }, any>>>;
+}>>, {
     right: string | number;
     bottom: string | number;
     show: boolean | undefined;

package/es/back-top/src/BackTop.js

@@ -1,4 +1,4 @@
-import { h, ref, computed, toRef, watch, nextTick, defineComponent, renderSlot, mergeProps, Transition, onMounted, onBeforeUnmount } from 'vue';
+import { h, ref, computed, toRef, watch, nextTick, defineComponent, mergeProps, Transition, onMounted, onBeforeUnmount } from 'vue';
 import { VLazyTeleport } from 'vueuc';
 import { useIsMounted, useMergedState } from 'vooks';
 import { getScrollParent, unwrapElement } from 'seemly';
@@ -206,9 +206,7 @@ export default defineComponent({
                             style: Object.assign(Object.assign({}, this.style), this.cssVars),
                             onClick: this.handleClick
                         }), [
-                            renderSlot(this.$slots, 'default', undefined, () => [
-                                h(NBaseIcon, { clsPrefix: mergedClsPrefix }, { default: () => BackTopIcon })
-                            ])
+                            this.$slots.default ? (this.$slots.default()) : (h(NBaseIcon, { clsPrefix: mergedClsPrefix }, { default: () => BackTopIcon }))
                         ])
                         : null
                 }))