naive-ui 2.40.4 → 2.41.1

package/lib/_utils/naive/value.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArrayShallowEqual = isArrayShallowEqual;
+function isArrayShallowEqual(array1, array2) {
+    if (array1 === null && array2 === null)
+        return true;
+    if (array1 === null || array2 === null)
+        return false;
+    if (array1.length === array2.length) {
+        for (let i = 0; i < array1.length; ++i) {
+            if (array1[i] !== array2[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/lib/_utils/vue/get-first-slot-vnode.d.ts

@@ -1,2 +1,3 @@
 import type { Slots, VNode } from 'vue';
 export declare function getFirstSlotVNode(slots: Slots, slotName?: string, props?: unknown): VNode | null;
+export declare function getFirstSlotVNodeWithTypedProps<T>(slotName: string, slot: ((props: T) => VNode[]) | undefined, props: T): VNode | null;

package/lib/_utils/vue/get-first-slot-vnode.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFirstSlotVNode = getFirstSlotVNode;
+exports.getFirstSlotVNodeWithTypedProps = getFirstSlotVNodeWithTypedProps;
 const naive_1 = require("../naive");
 const flatten_1 = require("./flatten");
 function getFirstSlotVNode(slots, slotName = 'default', props = undefined) {
@@ -19,3 +20,17 @@ function getFirstSlotVNode(slots, slotName = 'default', props = undefined) {
         return null;
     }
 }
+function getFirstSlotVNodeWithTypedProps(slotName, slot, props) {
+    if (!slot) {
+        return null;
+    }
+    const slotContent = (0, flatten_1.flatten)(slot(props));
+    // vue will normalize the slot, so slot must be an array
+    if (slotContent.length === 1) {
+        return slotContent[0];
+    }
+    else {
+        (0, naive_1.warn)('getFirstSlotVNode', `slot[${slotName}] should have exactly one child`);
+        return null;
+    }
+}

package/lib/_utils/vue/index.d.ts

@@ -4,7 +4,7 @@ export { createDataKey } from './create-data-key';
 export { createInjectionKey } from './create-injection-key';
 export { createRefSetter } from './create-ref-setter';
 export { flatten } from './flatten';
-export { getFirstSlotVNode } from './get-first-slot-vnode';
+export { getFirstSlotVNode, getFirstSlotVNodeWithTypedProps } from './get-first-slot-vnode';
 export { getSlot } from './get-slot';
 export { getVNodeChildren } from './get-v-node-children';
 export { isNodeVShowFalse } from './is-node-v-show-false';
@@ -13,5 +13,5 @@ export { keysOf } from './keysOf';
 export { mergeEventHandlers } from './merge-handlers';
 export { omit } from './omit';
 export { render } from './render';
-export { isSlotEmpty, resolveSlot, resolveSlotWithProps, resolveWrappedSlot, resolveWrappedSlotWithProps } from './resolve-slot';
+export { isSlotEmpty, resolveSlot, resolveSlotWithTypedProps, resolveWrappedSlot, resolveWrappedSlotWithProps } from './resolve-slot';
 export { Wrapper } from './wrapper';

package/lib/_utils/vue/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Wrapper = exports.resolveWrappedSlotWithProps = exports.resolveWrappedSlot = exports.resolveSlotWithProps = exports.resolveSlot = exports.isSlotEmpty = exports.render = exports.omit = exports.mergeEventHandlers = exports.keysOf = exports.keep = exports.isNodeVShowFalse = exports.getVNodeChildren = exports.getSlot = exports.getFirstSlotVNode = exports.flatten = exports.createRefSetter = exports.createInjectionKey = exports.createDataKey = exports.call = void 0;
+exports.Wrapper = exports.resolveWrappedSlotWithProps = exports.resolveWrappedSlot = exports.resolveSlotWithTypedProps = exports.resolveSlot = exports.isSlotEmpty = exports.render = exports.omit = exports.mergeEventHandlers = exports.keysOf = exports.keep = exports.isNodeVShowFalse = exports.getVNodeChildren = exports.getSlot = exports.getFirstSlotVNodeWithTypedProps = exports.getFirstSlotVNode = exports.flatten = exports.createRefSetter = exports.createInjectionKey = exports.createDataKey = exports.call = void 0;
 var call_1 = require("./call");
 Object.defineProperty(exports, "call", { enumerable: true, get: function () { return call_1.call; } });
 var create_data_key_1 = require("./create-data-key");
@@ -13,6 +13,7 @@ var flatten_1 = require("./flatten");
 Object.defineProperty(exports, "flatten", { enumerable: true, get: function () { return flatten_1.flatten; } });
 var get_first_slot_vnode_1 = require("./get-first-slot-vnode");
 Object.defineProperty(exports, "getFirstSlotVNode", { enumerable: true, get: function () { return get_first_slot_vnode_1.getFirstSlotVNode; } });
+Object.defineProperty(exports, "getFirstSlotVNodeWithTypedProps", { enumerable: true, get: function () { return get_first_slot_vnode_1.getFirstSlotVNodeWithTypedProps; } });
 var get_slot_1 = require("./get-slot");
 Object.defineProperty(exports, "getSlot", { enumerable: true, get: function () { return get_slot_1.getSlot; } });
 var get_v_node_children_1 = require("./get-v-node-children");
@@ -32,7 +33,7 @@ Object.defineProperty(exports, "render", { enumerable: true, get: function () {
 var resolve_slot_1 = require("./resolve-slot");
 Object.defineProperty(exports, "isSlotEmpty", { enumerable: true, get: function () { return resolve_slot_1.isSlotEmpty; } });
 Object.defineProperty(exports, "resolveSlot", { enumerable: true, get: function () { return resolve_slot_1.resolveSlot; } });
-Object.defineProperty(exports, "resolveSlotWithProps", { enumerable: true, get: function () { return resolve_slot_1.resolveSlotWithProps; } });
+Object.defineProperty(exports, "resolveSlotWithTypedProps", { enumerable: true, get: function () { return resolve_slot_1.resolveSlotWithTypedProps; } });
 Object.defineProperty(exports, "resolveWrappedSlot", { enumerable: true, get: function () { return resolve_slot_1.resolveWrappedSlot; } });
 Object.defineProperty(exports, "resolveWrappedSlotWithProps", { enumerable: true, get: function () { return resolve_slot_1.resolveWrappedSlotWithProps; } });
 var wrapper_1 = require("./wrapper");

package/lib/_utils/vue/resolve-slot.d.ts

@@ -4,7 +4,7 @@ export declare function ensureValidVNode(vnodes: VNodeArrayChildren): VNodeArray
  * We shouldn't use the following functions with slot flags `_: 1, 2, 3`
  */
 export declare function resolveSlot(slot: Slot | undefined, fallback: () => VNodeArrayChildren): VNodeArrayChildren;
-export declare function resolveSlotWithProps<T>(slot: Slot | undefined, props: T, fallback: (props: T) => VNodeArrayChildren): VNodeArrayChildren;
+export declare function resolveSlotWithTypedProps<T>(slot: Slot<T> | undefined, props: T, fallback: (props: T) => VNodeArrayChildren): VNodeArrayChildren;
 /**
  * Resolve slot with wrapper if content exists, no fallback
  */

package/lib/_utils/vue/resolve-slot.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureValidVNode = ensureValidVNode;
 exports.resolveSlot = resolveSlot;
-exports.resolveSlotWithProps = resolveSlotWithProps;
+exports.resolveSlotWithTypedProps = resolveSlotWithTypedProps;
 exports.resolveWrappedSlot = resolveWrappedSlot;
 exports.resolveWrappedSlotWithProps = resolveWrappedSlotWithProps;
 exports.isSlotEmpty = isSlotEmpty;
@@ -30,7 +30,7 @@ function ensureValidVNode(vnodes) {
 function resolveSlot(slot, fallback) {
     return (slot && ensureValidVNode(slot())) || fallback();
 }
-function resolveSlotWithProps(slot, props, fallback) {
+function resolveSlotWithTypedProps(slot, props, fallback) {
     return (slot && ensureValidVNode(slot(props))) || fallback(props);
 }
 /**

package/lib/alert/index.d.ts

@@ -1,2 +1,2 @@
 export { alertProps, default as NAlert } from './src/Alert';
-export type { AlertProps } from './src/Alert';
+export type { AlertProps, AlertSlots } from './src/Alert';

package/lib/alert/src/Alert.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractPublicPropTypes } from '../../_utils';
-import { type PropType } from 'vue';
+import { type PropType, type SlotsType, type VNode } from 'vue';
 export declare const alertProps: {
     title: StringConstructor;
     showIcon: {
@@ -216,6 +216,11 @@ export declare const alertProps: {
     }, any>>>;
 };
 export type AlertProps = ExtractPublicPropTypes<typeof alertProps>;
+export interface AlertSlots {
+    default?: () => VNode[];
+    icon?: () => VNode[];
+    header?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     title: StringConstructor;
     showIcon: {
@@ -758,5 +763,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     bordered: boolean;
     showIcon: boolean;
     closable: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AlertSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/alert/src/Alert.js

@@ -29,6 +29,7 @@ exports.default = (0, vue_1.defineComponent)({
     name: 'Alert',
     inheritAttrs: false,
     props: exports.alertProps,
+    slots: Object,
     setup(props) {
         if (process.env.NODE_ENV !== 'production') {
             (0, vue_1.watchEffect)(() => {

package/lib/auto-complete/index.d.ts

@@ -1,3 +1,3 @@
 export { autoCompleteProps, default as NAutoComplete } from './src/AutoComplete';
-export type { AutoCompleteProps } from './src/AutoComplete';
-export type { AutoCompleteGroupOption, AutoCompleteInst, AutoCompleteOption } from './src/interface';
+export type { AutoCompleteProps, AutoCompleteSlots } from './src/AutoComplete';
+export type { AutoCompleteDefaultSlotProps, AutoCompleteGroupOption, AutoCompleteInst, AutoCompleteOption } from './src/interface';

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

@@ -1,9 +1,9 @@
 import type { RenderLabel, RenderOption } from '../../_internal/select-menu/src/interface';
-import type { FormValidationStatus } from '../../form/src/interface';
+import type { FormValidationStatus } from '../../form/src/public-types';
 import type { SelectBaseOption, SelectGroupOption, SelectIgnoredOption } from '../../select/src/interface';
-import type { AutoCompleteOptions, OnSelect, OnUpdateValue } from './interface';
+import type { AutoCompleteDefaultSlotProps, AutoCompleteOptions, OnSelect, OnUpdateValue } from './interface';
 import { type TreeNode } from 'treemate';
-import { type HTMLAttributes, type InputHTMLAttributes, type PropType } from 'vue';
+import { type HTMLAttributes, type InputHTMLAttributes, type PropType, type SlotsType, type VNode } from 'vue';
 import { type FollowerPlacement } from 'vueuc';
 import { type ExtractPublicPropTypes, type MaybeArray } from '../../_utils';
 export declare const autoCompleteProps: {
@@ -460,6 +460,12 @@ export declare const autoCompleteProps: {
     }>>>;
 };
 export type AutoCompleteProps = ExtractPublicPropTypes<typeof autoCompleteProps>;
+export interface AutoCompleteSlots {
+    default?: (options: AutoCompleteDefaultSlotProps) => VNode[];
+    empty?: () => VNode[];
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly to: {
         type: PropType<HTMLElement | string | boolean>;
@@ -1636,5 +1642,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly blurAfterSelect: boolean;
     readonly clearAfterSelect: boolean;
     readonly showEmpty: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AutoCompleteSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -45,6 +45,7 @@ exports.autoCompleteProps = Object.assign(Object.assign({}, _mixins_1.useTheme.p
 exports.default = (0, vue_1.defineComponent)({
     name: 'AutoComplete',
     props: exports.autoCompleteProps,
+    slots: Object,
     setup(props) {
         if (process.env.NODE_ENV !== 'production') {
             (0, vue_1.watchEffect)(() => {
@@ -254,7 +255,7 @@ exports.default = (0, vue_1.defineComponent)({
                         default: () => {
                             const defaultSlot = this.$slots.default;
                             if (defaultSlot) {
-                                return (0, _utils_1.getFirstSlotVNode)(this.$slots, 'default', {
+                                return (0, _utils_1.getFirstSlotVNodeWithTypedProps)('default', defaultSlot, {
                                     handleInput: this.handleInput,
                                     handleFocus: this.handleFocus,
                                     handleBlur: this.handleBlur,

package/lib/auto-complete/src/interface.d.ts

@@ -12,3 +12,9 @@ export interface AutoCompleteInst {
     focus: () => void;
     blur: () => void;
 }
+export interface AutoCompleteDefaultSlotProps {
+    handleInput: (value: string) => void;
+    handleFocus: (e: FocusEvent) => void;
+    handleBlur: (e: FocusEvent) => void;
+    value: string | null;
+}

package/lib/avatar/index.d.ts

@@ -1,2 +1,2 @@
 export { avatarProps, default as NAvatar } from './src/Avatar';
-export type { AvatarProps } from './src/Avatar';
+export type { AvatarProps, AvatarSlots } from './src/Avatar';

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

@@ -1,6 +1,6 @@
 import type { ExtractPublicPropTypes } from '../../_utils';
 import type { ObjectFit, Size } from './interface';
-import { type ImgHTMLAttributes, type PropType, type VNodeChild } from 'vue';
+import { type ImgHTMLAttributes, type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
 import { type IntersectionObserverOptions } from '../../image/src/utils';
 export declare const avatarProps: {
     readonly size: PropType<Size>;
@@ -69,6 +69,11 @@ export declare const avatarProps: {
     }, any>>>;
 };
 export type AvatarProps = ExtractPublicPropTypes<typeof avatarProps>;
+export interface AvatarSlots {
+    default?: () => VNode[];
+    placeholder?: () => VNode[];
+    fallback?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly size: PropType<Size>;
     readonly src: StringConstructor;
@@ -227,5 +232,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly circle: boolean;
     readonly lazy: boolean;
     readonly bordered: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AvatarSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/avatar/src/Avatar.js

@@ -29,6 +29,7 @@ exports.avatarProps = Object.assign(Object.assign({}, _mixins_1.useTheme.props),
 exports.default = (0, vue_1.defineComponent)({
     name: 'Avatar',
     props: exports.avatarProps,
+    slots: Object,
     setup(props) {
         const { mergedClsPrefixRef, inlineThemeDisabled } = (0, _mixins_1.useConfig)(props);
         const hasLoadErrorRef = (0, vue_1.ref)(false);

package/lib/avatar-group/index.d.ts

@@ -1,2 +1,3 @@
 export { avatarGroupProps, default as NAvatarGroup } from './src/AvatarGroup';
-export type { AvatarGroupOption, AvatarGroupProps } from './src/AvatarGroup';
+export type { AvatarGroupOption, AvatarGroupProps, AvatarGroupSlots } from './src/AvatarGroup';
+export type { AvatarGroupAvatarSlotProps, AvatarGroupRestSlotProps } from './src/interface';

package/lib/avatar-group/src/AvatarGroup.d.ts

@@ -1,6 +1,7 @@
 import type { ExtractPublicPropTypes } from '../../_utils';
 import type { Size } from '../../avatar/src/interface';
-import { type CSSProperties, type PropType } from 'vue';
+import type { AvatarGroupAvatarSlotProps, AvatarGroupRestSlotProps } from './interface';
+import { type CSSProperties, type PropType, type SlotsType, type VNode } from 'vue';
 export interface AvatarGroupInjection {
     size?: Size | undefined;
 }
@@ -70,6 +71,11 @@ export declare const avatarGroupProps: {
     }>>>;
 };
 export type AvatarGroupProps = ExtractPublicPropTypes<typeof avatarGroupProps>;
+export interface AvatarGroupSlots {
+    avatar?: (props: AvatarGroupAvatarSlotProps) => VNode[];
+    rest?: (props: AvatarGroupRestSlotProps) => VNode[];
+    default?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly max: NumberConstructor;
     readonly maxStyle: PropType<CSSProperties | string>;
@@ -232,5 +238,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly options: AvatarGroupOption[];
     readonly vertical: boolean;
     readonly expandOnHover: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AvatarGroupSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/avatar-group/src/AvatarGroup.js

@@ -18,6 +18,7 @@ exports.avatarGroupProps = Object.assign(Object.assign({}, _mixins_1.useTheme.pr
 exports.default = (0, vue_1.defineComponent)({
     name: 'AvatarGroup',
     props: exports.avatarGroupProps,
+    slots: Object,
     setup(props) {
         const { mergedClsPrefixRef, mergedRtlRef } = (0, _mixins_1.useConfig)(props);
         const mergedThemeRef = (0, _mixins_1.useTheme)('AvatarGroup', '-avatar-group', avatar_group_cssr_1.default, styles_1.avatarGroupLight, props, mergedClsPrefixRef);

package/lib/avatar-group/src/interface.d.ts

@@ -0,0 +1,8 @@
+import type { AvatarGroupOption } from './AvatarGroup';
+export interface AvatarGroupAvatarSlotProps {
+    option: AvatarGroupOption;
+}
+export interface AvatarGroupRestSlotProps {
+    options: Array<AvatarGroupOption>;
+    rest: number;
+}

package/lib/avatar-group/src/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/breadcrumb/index.d.ts

@@ -1,4 +1,4 @@
 export { breadcrumbProps, default as NBreadcrumb } from './src/Breadcrumb';
 export type { BreadcrumbProps } from './src/Breadcrumb';
 export { breadcrumbItemProps, default as NBreadcrumbItem } from './src/BreadcrumbItem';
-export type { BreadcrumbItemProps } from './src/BreadcrumbItem';
+export type { BreadcrumbItemProps, BreadcrumbItemSlots } from './src/BreadcrumbItem';

package/lib/breadcrumb/src/BreadcrumbItem.d.ts

@@ -1,4 +1,4 @@
-import { type ExtractPropTypes, type PropType } from 'vue';
+import { type ExtractPropTypes, type PropType, type SlotsType, type VNode } from 'vue';
 export declare const breadcrumbItemProps: {
     readonly separator: StringConstructor;
     readonly href: StringConstructor;
@@ -9,6 +9,10 @@ export declare const breadcrumbItemProps: {
     readonly onClick: PropType<(e: MouseEvent) => void>;
 };
 export type BreadcrumbItemProps = Partial<ExtractPropTypes<typeof breadcrumbItemProps>>;
+export interface BreadcrumbItemSlots {
+    default?: () => VNode[];
+    separator?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     readonly separator: StringConstructor;
     readonly href: StringConstructor;
@@ -27,5 +31,5 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     readonly onClick: PropType<(e: MouseEvent) => void>;
 }>> & Readonly<{}>, {
     readonly clickable: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<BreadcrumbItemSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/breadcrumb/src/BreadcrumbItem.js

@@ -17,6 +17,7 @@ exports.breadcrumbItemProps = {
 exports.default = (0, vue_1.defineComponent)({
     name: 'BreadcrumbItem',
     props: exports.breadcrumbItemProps,
+    slots: Object,
     setup(props, { slots }) {
         const NBreadcrumb = (0, vue_1.inject)(Breadcrumb_1.breadcrumbInjectionKey, null);
         if (!NBreadcrumb) {

package/lib/button/index.d.ts

@@ -1,2 +1,2 @@
 export { buttonProps, default as NButton, XButton as NxButton } from './src/Button';
-export type { ButtonProps } from './src/Button';
+export type { ButtonProps, ButtonSlots } from './src/Button';

package/lib/button/src/Button.d.ts

@@ -1,7 +1,7 @@
 import type { BaseWaveRef } from '../../_internal';
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
 import type { Size, Type } from './interface';
-import { type ButtonHTMLAttributes, type ExtractPropTypes, type PropType, type VNodeChild } from 'vue';
+import { type ButtonHTMLAttributes, type ExtractPropTypes, type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
 export declare const buttonProps: {
     readonly color: StringConstructor;
     readonly textColor: StringConstructor;
@@ -666,6 +666,10 @@ export declare const buttonProps: {
     }, any>>>;
 };
 export type ButtonProps = ExtractPublicPropTypes<typeof buttonProps>;
+export interface ButtonSlots {
+    default?: () => VNode[];
+    icon?: () => VNode[];
+}
 declare const Button: import("vue").DefineComponent<ExtractPropTypes<{
     readonly color: StringConstructor;
     readonly textColor: StringConstructor;
@@ -2069,7 +2073,7 @@ declare const Button: import("vue").DefineComponent<ExtractPropTypes<{
     readonly iconPlacement: "left" | "right";
     readonly attrType: "reset" | "submit" | "button";
     readonly nativeFocusBehavior: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<ButtonSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 type InternalButtonProps = ExtractPropTypes<typeof buttonProps>;
 type NativeButtonProps = Omit<ButtonHTMLAttributes, keyof InternalButtonProps>;
 type MergedProps = Partial<InternalButtonProps & NativeButtonProps>;

package/lib/button/src/Button.js

@@ -44,6 +44,7 @@ exports.buttonProps = Object.assign(Object.assign({}, _mixins_1.useTheme.props),
 const Button = (0, vue_1.defineComponent)({
     name: 'Button',
     props: exports.buttonProps,
+    slots: Object,
     setup(props) {
         if (process.env.NODE_ENV !== 'production') {
             (0, vue_1.watchEffect)(() => {

package/lib/calendar/src/Calendar.d.ts

@@ -1,6 +1,6 @@
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import type { DateItem, OnPanelChange, OnUpdateValue } from './interface';
-import { type PropType } from 'vue';
+import type { CalendarDefaultSlotProps, CalendarHeaderSlotProps, DateItem, OnPanelChange, OnUpdateValue } from './interface';
+import { type PropType, type SlotsType, type VNode } from 'vue';
 export declare const calendarProps: {
     readonly isDateDisabled: PropType<(date: number) => boolean | undefined>;
     readonly value: NumberConstructor;
@@ -694,6 +694,10 @@ export declare const calendarProps: {
     }>>>;
 };
 export type CalendarProps = ExtractPublicPropTypes<typeof calendarProps>;
+export interface CalendarSlots {
+    default?: (props: CalendarDefaultSlotProps) => VNode[];
+    header?: (props: CalendarHeaderSlotProps) => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly isDateDisabled: PropType<(date: number) => boolean | undefined>;
     readonly value: NumberConstructor;
@@ -2413,5 +2417,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }>>>;
 }>> & Readonly<{}>, {
     readonly defaultValue: number | null;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<CalendarSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/calendar/src/Calendar.js

@@ -23,6 +23,7 @@ exports.calendarProps = Object.assign(Object.assign({}, _mixins_1.useTheme.props
 exports.default = (0, vue_1.defineComponent)({
     name: 'Calendar',
     props: exports.calendarProps,
+    slots: Object,
     setup(props) {
         var _a;
         const { mergedClsPrefixRef, inlineThemeDisabled } = (0, _mixins_1.useConfig)(props);
@@ -134,7 +135,7 @@ exports.default = (0, vue_1.defineComponent)({
         const calendarMonth = (0, date_fns_1.getMonth)(monthTs) + 1;
         return ((0, vue_1.h)("div", { class: [`${mergedClsPrefix}-calendar`, this.themeClass], style: cssVars },
             (0, vue_1.h)("div", { class: `${mergedClsPrefix}-calendar-header` },
-                (0, vue_1.h)("div", { class: `${mergedClsPrefix}-calendar-header__title` }, (0, _utils_1.resolveSlotWithProps)($slots.header, { year, month: calendarMonth }, () => {
+                (0, vue_1.h)("div", { class: `${mergedClsPrefix}-calendar-header__title` }, (0, _utils_1.resolveSlotWithTypedProps)($slots.header, { year, month: calendarMonth }, () => {
                     const localeMonth = (0, date_fns_1.format)(monthTs, 'MMMM', { locale });
                     return [
                         monthBeforeYear

package/lib/calendar/src/interface.d.ts

@@ -8,3 +8,12 @@ export type OnPanelChange = (info: {
     year: number;
     month: number;
 }) => void;
+export interface CalendarDefaultSlotProps {
+    year: number;
+    month: number;
+    date: number;
+}
+export interface CalendarHeaderSlotProps {
+    year: number;
+    month: number;
+}

package/lib/card/index.d.ts

@@ -1,2 +1,2 @@
 export { cardProps, default as NCard } from './src/Card';
-export type { CardProps, CardSegmented } from './src/Card';
+export type { CardProps, CardSegmented, CardSlots } from './src/Card';

package/lib/card/src/Card.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import { type CSSProperties, type PropType, type VNodeChild } from 'vue';
+import { type CSSProperties, type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
 export interface CardSegmented {
     content?: boolean | 'soft';
     footer?: boolean | 'soft';
@@ -192,6 +192,14 @@ export declare const cardProps: {
     }, any>>>;
 };
 export type CardProps = ExtractPublicPropTypes<typeof cardProps>;
+export interface CardSlots {
+    default?: () => VNode[];
+    cover?: () => VNode[];
+    header?: () => VNode[];
+    'header-extra'?: () => VNode[];
+    footer?: () => VNode[];
+    action?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     title: PropType<string | (() => VNodeChild)>;
     contentClass: StringConstructor;
@@ -575,5 +583,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     hoverable: boolean;
     embedded: boolean;
     segmented: boolean | CardSegmented;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<CardSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/card/src/Card.js

@@ -55,6 +55,7 @@ exports.cardProps = Object.assign(Object.assign({}, _mixins_1.useTheme.props), e
 exports.default = (0, vue_1.defineComponent)({
     name: 'Card',
     props: exports.cardProps,
+    slots: Object,
     setup(props) {
         const handleCloseClick = () => {
             const { onClose } = props;

package/lib/carousel/index.d.ts

@@ -1,4 +1,4 @@
 export { carouselProps, default as NCarousel } from './src/Carousel';
-export type { CarouselProps } from './src/Carousel';
+export type { CarouselProps, CarouselSlots } from './src/Carousel';
 export { default as NCarouselItem } from './src/CarouselItem';
-export type { CarouselInst } from './src/interface';
+export type { CarouselArrowSlotProps, CarouselDotSlotProps, CarouselInst } from './src/interface';

package/lib/carousel/src/Carousel.d.ts

@@ -1,6 +1,6 @@
-import type { CSSProperties, PropType, Ref, TransitionProps, VNode } from 'vue';
+import type { CSSProperties, PropType, Ref, SlotsType, TransitionProps, VNode } from 'vue';
 import type { ExtractPublicPropTypes } from '../../_utils';
-import type { ArrowScopedSlotProps, DotScopedSlotProps, Size } from './interface';
+import type { ArrowScopedSlotProps, CarouselArrowSlotProps, CarouselDotSlotProps, DotScopedSlotProps, Size } from './interface';
 declare const transitionProperties: readonly ["transitionDuration", "transitionTimingFunction"];
 type TransitionStyle = Partial<Pick<CSSProperties, (typeof transitionProperties)[number]>>;
 export declare const carouselProps: {
@@ -97,6 +97,11 @@ export declare const carouselProps: {
     }, any>>>;
 };
 export type CarouselProps = ExtractPublicPropTypes<typeof carouselProps>;
+export interface CarouselSlots {
+    default?: () => VNode[];
+    arrow?: (props: CarouselArrowSlotProps) => VNode[];
+    dots?: (props: CarouselDotSlotProps) => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     defaultIndex: {
         type: NumberConstructor;
@@ -343,5 +348,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     transitionStyle: Partial<Pick<CSSProperties, "transitionDuration" | "transitionTimingFunction">>;
     touchable: boolean;
     mousewheel: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<CarouselSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/lib/carousel/src/Carousel.js

@@ -92,6 +92,7 @@ let globalDragging = false;
 exports.default = (0, vue_1.defineComponent)({
     name: 'Carousel',
     props: exports.carouselProps,
+    slots: Object,
     setup(props) {
         const { mergedClsPrefixRef, inlineThemeDisabled } = (0, _mixins_1.useConfig)(props);
         // Dom
@@ -792,11 +793,11 @@ exports.default = (0, vue_1.defineComponent)({
             }),
             this.showDots
                 && dotSlotProps.total > 1
-                && (0, _utils_1.resolveSlotWithProps)(dotsSlot, dotSlotProps, () => [
+                && (0, _utils_1.resolveSlotWithTypedProps)(dotsSlot, dotSlotProps, () => [
                     (0, vue_1.h)(CarouselDots_1.default, { key: dotType + dotPlacement, total: dotSlotProps.total, currentIndex: dotSlotProps.currentIndex, dotType: dotType, trigger: this.trigger, keyboard: this.keyboard })
                 ]),
             showArrow
-                && (0, _utils_1.resolveSlotWithProps)(arrowSlot, arrowSlotProps, () => [
+                && (0, _utils_1.resolveSlotWithTypedProps)(arrowSlot, arrowSlotProps, () => [
                     (0, vue_1.h)(CarouselArrow_1.default, null)
                 ])));
     }

package/lib/carousel/src/interface.d.ts

@@ -17,3 +17,15 @@ export interface Size {
     width: number;
     height: number;
 }
+export interface CarouselArrowSlotProps {
+    total: number;
+    currentIndex: number;
+    to: (index: number) => void;
+    prev: () => void;
+    next: () => void;
+}
+export interface CarouselDotSlotProps {
+    total: number;
+    currentIndex: number;
+    to: (index: number) => void;
+}

package/lib/cascader/index.d.ts

@@ -1,3 +1,3 @@
 export { cascaderProps, default as NCascader } from './src/Cascader';
-export type { CascaderProps } from './src/Cascader';
+export type { CascaderProps, CascaderSlots } from './src/Cascader';
 export type { CascaderInst, CascaderOption } from './src/interface';