antdv-next 1.0.1 → 1.0.3-beta.1

package/dist/_util/ActionButton.d.ts

@@ -1,7 +1,7 @@
 import { EmptyEmit } from "./type.js";
 import { ButtonProps, LegacyButtonType } from "../button/Button.js";
 import "../button/index.js";
-import * as vue761 from "vue";
+import * as vue18 from "vue";
 import { SlotsType } from "vue";
 
 //#region src/_util/ActionButton.d.ts
@@ -20,8 +20,6 @@ interface ActionButtonProps {
 interface ActionButtonSlots {
   default?: () => any;
 }
-declare const ActionButton: vue761.DefineSetupFnComponent<ActionButtonProps, EmptyEmit, SlotsType<ActionButtonSlots>, ActionButtonProps & {
-  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
-}, vue761.PublicProps>;
+declare const ActionButton: vue18.DefineSetupFnComponent<ActionButtonProps, EmptyEmit, SlotsType<ActionButtonSlots>, ActionButtonProps, vue18.PublicProps>;
 //#endregion
 export { ActionButtonProps, ActionButtonSlots, ActionButton as default };

package/dist/_util/ActionButton.js

@@ -29,10 +29,10 @@ const ActionButton = /* @__PURE__ */ defineComponent((props, { slots }) => {
 	const onInternalClose = (...args) => {
 		props.close?.(...args);
 	};
-	const handlePromiseOnOk = (returnValue) => {
-		if (!isThenable(returnValue)) return;
+	const handlePromiseOnOk = (returnValueOfOnOk) => {
+		if (!isThenable(returnValueOfOnOk)) return;
 		loading.value = true;
-		returnValue.then((...args) => {
+		returnValueOfOnOk.then((...args) => {
 			loading.value = false;
 			clicked.value = false;
 			onInternalClose(...args);
@@ -51,25 +51,25 @@ const ActionButton = /* @__PURE__ */ defineComponent((props, { slots }) => {
 			onInternalClose();
 			return;
 		}
-		let returnValue;
+		let returnValueOfOnOk;
 		if (props.emitEvent) {
-			returnValue = actionFn(e);
-			if (props.quitOnNullishReturnValue && !isThenable(returnValue)) {
+			returnValueOfOnOk = actionFn(e);
+			if (props.quitOnNullishReturnValue && !isThenable(returnValueOfOnOk)) {
 				clicked.value = false;
 				onInternalClose(e);
 				return;
 			}
 		} else if (actionFn.length) {
-			returnValue = actionFn(onInternalClose);
+			returnValueOfOnOk = actionFn(onInternalClose);
 			clicked.value = false;
 		} else {
-			returnValue = actionFn();
-			if (!isThenable(returnValue)) {
+			returnValueOfOnOk = actionFn();
+			if (!isThenable(returnValueOfOnOk)) {
 				onInternalClose();
 				return;
 			}
 		}
-		handlePromiseOnOk(returnValue);
+		handlePromiseOnOk(returnValueOfOnOk);
 	};
 	return () => {
 		const buttonAttrs = props.buttonProps ?? {};

package/dist/_util/ContextIsolator.d.ts

@@ -1,12 +1,12 @@
-import * as vue757 from "vue";
+import * as vue177 from "vue";
 
 //#region src/_util/ContextIsolator.d.ts
-declare const ContextIsolator: vue757.DefineSetupFnComponent<{
+declare const ContextIsolator: vue177.DefineSetupFnComponent<{
   space?: boolean;
   form?: boolean;
 }, {}, {}, {
   space?: boolean;
   form?: boolean;
-} & {}, vue757.PublicProps>;
+} & {}, vue177.PublicProps>;
 //#endregion
 export { ContextIsolator };

package/dist/_util/PurePanel.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties } from "vue";
-import * as vue_jsx_runtime30 from "vue/jsx-runtime";
+import * as vue_jsx_runtime9 from "vue/jsx-runtime";
 
 //#region src/_util/PurePanel.d.ts
 interface BaseProps {
@@ -7,7 +7,7 @@ interface BaseProps {
   style?: CSSProperties;
   open?: boolean;
 }
-declare function withPureRenderTheme(Component: any): (props: any) => vue_jsx_runtime30.JSX.Element;
-declare function genPurePanel(Component: any, alignPropName?: 'align' | 'dropdownAlign' | 'popupAlign', postProps?: (props: any) => any, defaultPrefixCls?: string, getDropdownCls?: (prefixCls: string) => string): (props: any) => vue_jsx_runtime30.JSX.Element;
+declare function withPureRenderTheme(Component: any): (props: any) => vue_jsx_runtime9.JSX.Element;
+declare function genPurePanel(Component: any, alignPropName?: 'align' | 'dropdownAlign' | 'popupAlign', postProps?: (props: any) => any, defaultPrefixCls?: string, getDropdownCls?: (prefixCls: string) => string): (props: any) => vue_jsx_runtime9.JSX.Element;
 //#endregion
 export { BaseProps, genPurePanel as default, withPureRenderTheme };

package/dist/_util/convertToTooltipProps.d.ts

@@ -2,6 +2,6 @@ import { VueNode } from "./type.js";
 import { TooltipProps } from "../tooltip/index.js";
 
 //#region src/_util/convertToTooltipProps.d.ts
-declare function convertToTooltipProps<P extends TooltipProps>(tooltip?: P | VueNode): P | null;
+declare function convertToTooltipProps<P extends TooltipProps>(tooltip?: P | VueNode, context?: P): P | null;
 //#endregion
 export { convertToTooltipProps as default };

package/dist/_util/convertToTooltipProps.js

@@ -1,10 +1,16 @@
 import { isVNode } from "vue";
 
 //#region src/_util/convertToTooltipProps.ts
-function convertToTooltipProps(tooltip) {
+function convertToTooltipProps(tooltip, context) {
 	if (tooltip === void 0 || tooltip === null) return null;
-	if (typeof tooltip === "object" && !Array.isArray(tooltip) && !isVNode(tooltip)) return tooltip;
-	return { title: tooltip };
+	if (typeof tooltip === "object" && !Array.isArray(tooltip) && !isVNode(tooltip)) return {
+		...context,
+		...tooltip
+	};
+	return {
+		...context,
+		title: tooltip
+	};
 }
 
 //#endregion

package/dist/_util/hooks/index.d.ts

@@ -1,6 +1,6 @@
-import { MaskConfig, MaskType, useMergedMask } from "./useMergedMask.js";
-import { Resolvable, SemanticClassNames, SemanticClassNamesType, SemanticSchema, SemanticStyles, SemanticStylesType, getAttrStyleAndClass, mergeClassNames, mergeStyles, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useToArr, useToProps } from "./useMergeSemantic.js";
+import { MaskConfig, MaskType, normalizeMaskConfig, useMergedMask } from "./useMergedMask.js";
+import { Resolvable, SemanticClassNames, SemanticClassNamesType, SemanticSchema, SemanticStyles, SemanticStylesType, SemanticType, getAttrStyleAndClass, mergeClassNames, mergeStyles, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useToArr, useToProps } from "./useMergeSemantic.js";
 import { PrevSelectedIndex, useMultipleSelect } from "./useMultipleSelect.js";
 import { Orientation, useOrientation } from "./useOrientation.js";
 import { CONTAINER_MAX_OFFSET, ZIndexConsumer, ZIndexContainer, consumerBaseZIndexOffset, containerBaseZIndexOffset, useZIndex } from "./useZIndex.js";
-export { CONTAINER_MAX_OFFSET, MaskConfig, MaskType, Orientation, PrevSelectedIndex, Resolvable, SemanticClassNames, SemanticClassNamesType, SemanticSchema, SemanticStyles, SemanticStylesType, ZIndexConsumer, ZIndexContainer, consumerBaseZIndexOffset, containerBaseZIndexOffset, getAttrStyleAndClass, mergeClassNames, mergeStyles, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useMergedMask, useMultipleSelect, useOrientation, useToArr, useToProps, useZIndex };
+export { CONTAINER_MAX_OFFSET, MaskConfig, MaskType, Orientation, PrevSelectedIndex, Resolvable, SemanticClassNames, SemanticClassNamesType, SemanticSchema, SemanticStyles, SemanticStylesType, SemanticType, ZIndexConsumer, ZIndexContainer, consumerBaseZIndexOffset, containerBaseZIndexOffset, getAttrStyleAndClass, mergeClassNames, mergeStyles, normalizeMaskConfig, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useMergedMask, useMultipleSelect, useOrientation, useToArr, useToProps, useZIndex };

package/dist/_util/hooks/index.js

@@ -1,7 +1,7 @@
-import { useMergedMask } from "./useMergedMask.js";
+import { normalizeMaskConfig, useMergedMask } from "./useMergedMask.js";
 import { getAttrStyleAndClass, mergeClassNames, mergeStyles, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useToArr, useToProps } from "./useMergeSemantic.js";
 import { useMultipleSelect } from "./useMultipleSelect.js";
 import { useOrientation } from "./useOrientation.js";
 import { CONTAINER_MAX_OFFSET, consumerBaseZIndexOffset, containerBaseZIndexOffset, useZIndex } from "./useZIndex.js";
 
-export { CONTAINER_MAX_OFFSET, consumerBaseZIndexOffset, containerBaseZIndexOffset, getAttrStyleAndClass, mergeClassNames, mergeStyles, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useMergedMask, useMultipleSelect, useOrientation, useToArr, useToProps, useZIndex };
+export { CONTAINER_MAX_OFFSET, consumerBaseZIndexOffset, containerBaseZIndexOffset, getAttrStyleAndClass, mergeClassNames, mergeStyles, normalizeMaskConfig, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useMergedMask, useMultipleSelect, useOrientation, useToArr, useToProps, useZIndex };

package/dist/_util/hooks/useClosable.d.ts

@@ -1,5 +1,5 @@
 import { RenderNodeFn, VueNode } from "../type.js";
-import * as vue85 from "vue";
+import * as vue89 from "vue";
 import { AriaAttributes, Ref, VNodeChild } from "vue";
 
 //#region src/_util/hooks/useClosable.d.ts
@@ -36,7 +36,7 @@ interface UseClosableParams {
   customCloseIconRender?: (closeIcon: VNodeChild) => VNodeChild;
   context?: ContextClosable;
 }
-declare function useClosable(propCloseCollection?: Ref<ClosableCollection>, contextCloseCollection?: Ref<ClosableCollection | null>, fallbackCloseCollection?: Ref<FallbackCloseCollection>): vue85.ComputedRef<readonly [true, vue85.VNode<vue85.RendererNode, vue85.RendererElement, {
+declare function useClosable(propCloseCollection?: Ref<ClosableCollection>, contextCloseCollection?: Ref<ClosableCollection | null>, fallbackCloseCollection?: Ref<FallbackCloseCollection>): vue89.ComputedRef<readonly [true, vue89.VNode<vue89.RendererNode, vue89.RendererElement, {
   [key: string]: any;
 }>, boolean, Record<string, any>] | ({} | null)[] | undefined>;
 declare function computeClosable(propCloseCollection?: Ref<ClosableCollection>, contextCloseCollection?: Ref<ClosableCollection | null>, fallbackCloseCollection?: Ref<FallbackCloseCollection>, closeLabel?: string): [closable: boolean, closeIcon: VueNode, closeBtnIsDisabled: boolean, ariaOrDataProps: AriaAttributes & DataAttributes];

package/dist/_util/hooks/useMergeSemantic.d.ts

@@ -1,5 +1,5 @@
 import { AnyObject, EmptyObject, ValidChar } from "../type.js";
-import * as vue151 from "vue";
+import * as vue950 from "vue";
 import { CSSProperties, Ref } from "vue";
 
 //#region src/_util/hooks/useMergeSemantic.d.ts
@@ -13,6 +13,9 @@ type SemanticStyles<Name extends string> = Partial<Record<Name, CSSProperties>>;
 type Resolvable<T, P extends AnyObject> = T | ((info: {
   props: P;
 }) => T);
+type SemanticType<P = any, T = any> = T | ((info: {
+  props: P;
+}) => T);
 type SemanticClassNamesType<Props extends AnyObject, SemanticClassNames extends { [K in keyof SemanticClassNames]?: string }, NestedStructure extends EmptyObject = EmptyObject> = Resolvable<Readonly<SemanticClassNames>, Props> & NestedStructure;
 type SemanticStylesType<Props extends AnyObject, SemanticStyles extends { [K in keyof SemanticStyles]?: CSSProperties }, NestedStructure extends EmptyObject = EmptyObject> = Resolvable<Readonly<SemanticStyles>, Props> & NestedStructure;
 declare function mergeClassNames<Name extends string, SemanticClassNames extends Partial<Record<Name, any>>>(schema?: SemanticSchema, ...classNames: (SemanticClassNames | undefined)[]): SemanticClassNames;
@@ -34,12 +37,12 @@ type ObjectOnly<T> = T extends ((...args: any) => any) ? never : T;
  */
 declare function useMergeSemantic<ClassNamesType extends AnyObject, StylesType extends AnyObject, Props extends AnyObject>(classNamesList: Ref<MaybeFn<ClassNamesType, Props>[]>, stylesList: Ref<MaybeFn<StylesType, Props>[]>, info: Ref<{
   props: Props;
-}>, schema?: Ref<SemanticSchema>): readonly [vue151.ComputedRef<ObjectOnly<ClassNamesType>>, vue151.ComputedRef<ObjectOnly<StylesType>>];
+}>, schema?: Ref<SemanticSchema>): readonly [vue950.ComputedRef<ObjectOnly<ClassNamesType>>, vue950.ComputedRef<ObjectOnly<StylesType>>];
 declare function useMergeSemanticNoRef<ClassNamesType extends AnyObject, StylesType extends AnyObject, Props extends AnyObject>(classNamesList: MaybeFn<ClassNamesType, Props>[], stylesList: MaybeFn<StylesType, Props>[], info: {
   props: Props;
 }, schema?: SemanticSchema): readonly [ObjectOnly<ClassNamesType>, ObjectOnly<StylesType>];
-declare function useToArr<T = any>(...args: Ref<T | undefined>[]): vue151.ComputedRef<(T | undefined)[]>;
-declare function useToProps<T>(props: Ref<T>): vue151.ComputedRef<{
+declare function useToArr<T = any>(...args: Ref<T | undefined>[]): vue950.ComputedRef<(T | undefined)[]>;
+declare function useToProps<T>(props: Ref<T>): vue950.ComputedRef<{
   props: T;
 }>;
 interface RemoveBaseAttributesOptions {
@@ -56,4 +59,4 @@ declare function getAttrStyleAndClass(attrs: Record<string, any>, options?: Remo
   restAttrs: Record<string, any>;
 };
 //#endregion
-export { Resolvable, SemanticClassNames, SemanticClassNamesType, SemanticSchema, SemanticStyles, SemanticStylesType, getAttrStyleAndClass, mergeClassNames, mergeStyles, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useToArr, useToProps };
+export { Resolvable, SemanticClassNames, SemanticClassNamesType, SemanticSchema, SemanticStyles, SemanticStylesType, SemanticType, getAttrStyleAndClass, mergeClassNames, mergeStyles, pureAttrs, resolveStyleOrClass, useMergeSemantic, useMergeSemanticNoRef, useToArr, useToProps };

package/dist/_util/hooks/useMergedMask.d.ts

@@ -1,14 +1,16 @@
-import * as vue164 from "vue";
+import * as vue947 from "vue";
 import { Ref } from "vue";
 
 //#region src/_util/hooks/useMergedMask.d.ts
 interface MaskConfig {
   enabled?: boolean;
   blur?: boolean;
+  closable?: boolean;
 }
 type MaskType = MaskConfig | boolean;
-declare function useMergedMask(mask: Ref<MaskType | undefined>, contextMask: Ref<MaskType | undefined>, prefixCls: Ref<string | undefined>): readonly [vue164.ComputedRef<boolean>, vue164.ComputedRef<{
+declare function normalizeMaskConfig(mask?: MaskType, maskClosable?: boolean): MaskConfig;
+declare function useMergedMask(mask: Ref<MaskType | undefined>, contextMask: Ref<MaskType | undefined>, prefixCls: Ref<string | undefined>, maskClosable?: Ref<boolean | undefined>): readonly [vue947.ComputedRef<boolean>, vue947.ComputedRef<{
   mask: string | undefined;
-}>];
+}>, vue947.ComputedRef<boolean>];
 //#endregion
-export { MaskConfig, MaskType, useMergedMask };
+export { MaskConfig, MaskType, normalizeMaskConfig, useMergedMask };

package/dist/_util/hooks/useMergedMask.js

@@ -1,29 +1,36 @@
-import { computed } from "vue";
+import { computed, unref } from "vue";
 
 //#region src/_util/hooks/useMergedMask.ts
-function normalizeMaskConfig(mask) {
-	if (mask && typeof mask === "object") return mask;
-	if (typeof mask === "boolean") return {
-		enabled: mask,
-		blur: mask
-	};
-	return {};
+function normalizeMaskConfig(mask, maskClosable) {
+	let maskConfig = {};
+	if (mask && typeof mask === "object") maskConfig = mask;
+	if (typeof mask === "boolean") maskConfig = { enabled: mask };
+	if (maskConfig.closable === void 0 && maskClosable !== void 0) maskConfig.closable = maskClosable;
+	return maskConfig;
 }
-function useMergedMask(mask, contextMask, prefixCls) {
+function useMergedMask(mask, contextMask, prefixCls, maskClosable) {
 	const context = computed(() => {
-		const maskConfig = normalizeMaskConfig(mask.value);
+		const maskConfig = normalizeMaskConfig(mask.value, unref(maskClosable));
+		const contextMaskConfig = normalizeMaskConfig(contextMask.value);
 		const mergedConfig = {
-			...normalizeMaskConfig(contextMask.value),
-			...maskConfig
+			blur: false,
+			...contextMaskConfig,
+			...maskConfig,
+			closable: maskConfig.closable ?? unref(maskClosable) ?? contextMaskConfig.closable ?? true
 		};
-		const className = mergedConfig.blur !== false ? `${prefixCls.value}-mask-blur` : void 0;
+		const className = mergedConfig.blur ? `${prefixCls.value}-mask-blur` : void 0;
 		return {
 			enabled: mergedConfig.enabled !== false,
-			classNames: { mask: className }
+			classNames: { mask: className },
+			closable: !!mergedConfig.closable
 		};
 	});
-	return [computed(() => context.value.enabled), computed(() => context.value.classNames)];
+	return [
+		computed(() => context.value.enabled),
+		computed(() => context.value.classNames),
+		computed(() => context.value.closable)
+	];
 }
 
 //#endregion
-export { useMergedMask };
+export { normalizeMaskConfig, useMergedMask };

package/dist/_util/hooks/useResponsive.d.ts

@@ -3,6 +3,6 @@ import { Ref } from "vue";
 
 //#region src/_util/hooks/useResponsive.d.ts
 declare function convertBreakpointToResponsive<T extends Partial<Record<Breakpoint, any>>>(breakpoints: T): any;
-declare function useResponsive(): Record<Breakpoint | "mobile" | "tablet" | "laptop" | "desktop", Ref<boolean, boolean>>;
+declare function useResponsive(): Record<"xxxl" | "xxl" | "xl" | "lg" | "md" | "sm" | "xs" | "mobile" | "tablet" | "laptop" | "desktop", Ref<boolean, boolean>>;
 //#endregion
 export { convertBreakpointToResponsive, useResponsive };

package/dist/_util/instance.d.ts

@@ -1,6 +1,6 @@
-import * as vue3 from "vue";
+import * as vue1 from "vue";
 
 //#region src/_util/instance.d.ts
-declare function getVueInstance(): vue3.AppContext | null;
+declare function getVueInstance(): vue1.AppContext | null;
 //#endregion
 export { getVueInstance };

package/dist/_util/responsiveObserver.d.ts

@@ -1,11 +1,12 @@
-import * as vue8 from "vue";
+import * as vue20 from "vue";
 
 //#region src/_util/responsiveObserver.d.ts
-type Breakpoint = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+declare const responsiveArray: readonly ["xxxl", "xxl", "xl", "lg", "md", "sm", "xs"];
+declare const responsiveArrayReversed: ("xxxl" | "xxl" | "xl" | "lg" | "md" | "sm" | "xs")[];
+type Breakpoint = (typeof responsiveArray)[number];
 type BreakpointMap = Record<Breakpoint, string>;
 type ScreenMap = Partial<Record<Breakpoint, boolean>>;
 type ScreenSizeMap = Partial<Record<Breakpoint, number>>;
-declare const responsiveArray: Breakpoint[];
 type SubscribeFunc = (screens: ScreenMap) => void;
 declare function matchScreen(screens: ScreenMap, screenSizes?: ScreenSizeMap): number | undefined;
 interface ResponsiveObserverType {
@@ -20,6 +21,6 @@ interface ResponsiveObserverType {
     listener: (this: MediaQueryList, ev: MediaQueryListEvent) => void;
   }>;
 }
-declare function useResponsiveObserver(): vue8.ComputedRef<ResponsiveObserverType>;
+declare function useResponsiveObserver(): vue20.ComputedRef<ResponsiveObserverType>;
 //#endregion
-export { Breakpoint, BreakpointMap, ScreenMap, ScreenSizeMap, useResponsiveObserver as default, matchScreen, responsiveArray };
+export { Breakpoint, BreakpointMap, ScreenMap, ScreenSizeMap, useResponsiveObserver as default, matchScreen, responsiveArray, responsiveArrayReversed };

package/dist/_util/responsiveObserver.js

@@ -5,6 +5,7 @@ import { computed } from "vue";
 
 //#region src/_util/responsiveObserver.ts
 const responsiveArray = [
+	"xxxl",
 	"xxl",
 	"xl",
 	"lg",
@@ -12,6 +13,7 @@ const responsiveArray = [
 	"sm",
 	"xs"
 ];
+const responsiveArrayReversed = [...responsiveArray].reverse();
 function getResponsiveMap(token) {
 	return {
 		xs: `(max-width: ${token.screenXSMax}px)`,
@@ -19,7 +21,8 @@ function getResponsiveMap(token) {
 		md: `(min-width: ${token.screenMD}px)`,
 		lg: `(min-width: ${token.screenLG}px)`,
 		xl: `(min-width: ${token.screenXL}px)`,
-		xxl: `(min-width: ${token.screenXXL}px)`
+		xxl: `(min-width: ${token.screenXXL}px)`,
+		xxxl: `(min-width: ${token.screenXXXL}px)`
 	};
 }
 /**
@@ -103,4 +106,4 @@ function useResponsiveObserver() {
 var responsiveObserver_default = useResponsiveObserver;
 
 //#endregion
-export { responsiveObserver_default as default, matchScreen, responsiveArray };
+export { responsiveObserver_default as default, matchScreen, responsiveArray, responsiveArrayReversed };

package/dist/_util/statusUtils.d.ts

@@ -4,6 +4,6 @@ import { ValidateStatus } from "../form/FormItem/index.js";
 declare const _InputStatuses: readonly ["warning", "error", "", "success", "validating"];
 type InputStatus = (typeof _InputStatuses)[number];
 declare function getStatusClassNames(prefixCls: string, status?: ValidateStatus, hasFeedback?: boolean): string;
-declare function getMergedStatus(contextStatus?: ValidateStatus, customStatus?: InputStatus): "" | "success" | "error" | "warning" | "validating" | undefined;
+declare function getMergedStatus(contextStatus?: ValidateStatus, customStatus?: InputStatus): "" | "success" | "warning" | "error" | "validating" | undefined;
 //#endregion
 export { InputStatus, getMergedStatus, getStatusClassNames };

package/dist/_util/type.d.ts

@@ -6,12 +6,8 @@ type EmptyObject = Record<never, never>;
 type RenderNodeFn<Args extends any[] = any[]> = (...args: Args) => VNodeChild;
 type VueNode<Args extends any[] = any[]> = RenderNodeFn<Args> | string | number | null | undefined | VNode | boolean;
 type EmitsArrToEvent<T extends Record<string, any>> = { [K in keyof T]: T[K] extends any[] ? (...args: T[K]) => void : T[K] };
-type EmitsType<T extends Record<string, any>> = EmitsArrToEvent<T> & {
-  [key: string]: (...args: any[]) => void;
-};
-interface EmptyEmit {
-  [key: string]: (...args: any[]) => void;
-}
+type EmitsType<T extends Record<string, any>> = EmitsArrToEvent<T>;
+interface EmptyEmit {}
 type SlotsDefineType<T extends Record<string, any> = Record<string, any>> = {
   default?: () => any;
 } & T;

package/dist/_util/vueNode.d.ts

@@ -1,19 +1,20 @@
 import { AnyObject, VueNode } from "./type.js";
-import * as vue502 from "vue";
+import * as vue560 from "vue";
 import { VNodeChild } from "vue";
 import { isFragment } from "@v-c/util/dist/Children/isFragment";
 
 //#region src/_util/vueNode.d.ts
 type RenderProps = AnyObject | ((originProps: AnyObject) => AnyObject | undefined);
-declare function replaceElement(element: VNodeChild, replacement: VNodeChild, props?: RenderProps): string | number | boolean | void | vue502.VNode<vue502.RendererNode, vue502.RendererElement, {
+declare function replaceElement(element: VNodeChild, replacement: VNodeChild, props?: RenderProps): string | number | boolean | void | vue560.VNode<vue560.RendererNode, vue560.RendererElement, {
   [key: string]: any;
-}> | vue502.VNodeArrayChildren | null;
-declare function cloneElement(element: VNodeChild, props?: RenderProps): string | number | boolean | void | vue502.VNode<vue502.RendererNode, vue502.RendererElement, {
+}> | vue560.VNodeArrayChildren | null;
+declare function cloneElement(element: VNodeChild, props?: RenderProps): string | number | boolean | void | vue560.VNode<vue560.RendererNode, vue560.RendererElement, {
   [key: string]: any;
-}> | vue502.VNodeArrayChildren | null;
+}> | vue560.VNodeArrayChildren | null;
 declare function getVNode(node: VueNode): VNodeChild;
 declare function checkRenderNode(node: any): any;
 declare function getTextByNode(node: any): any;
 declare function getTextNodeArr(nodes: any[]): any[];
+type EmitToProps<T extends Record<string, any>> = { [K in keyof T as `on${Capitalize<K & string>}`]: T[K] };
 //#endregion
-export { checkRenderNode, cloneElement, getTextByNode, getTextNodeArr, getVNode, isFragment, replaceElement };
+export { EmitToProps, checkRenderNode, cloneElement, getTextByNode, getTextNodeArr, getVNode, isFragment, replaceElement };

package/dist/_util/wave/WaveEffect.d.ts

@@ -1,11 +1,11 @@
 import { ShowWaveEffect, WaveComponent } from "./interface.js";
 import { WaveProps } from "./index.js";
-import * as vue363 from "vue";
+import * as vue976 from "vue";
 import { PropType } from "vue";
-import * as vue_jsx_runtime10 from "vue/jsx-runtime";
+import * as vue_jsx_runtime33 from "vue/jsx-runtime";
 
 //#region src/_util/wave/WaveEffect.d.ts
-declare const WaveEffect: vue363.DefineComponent<vue363.ExtractPropTypes<{
+declare const WaveEffect: vue976.DefineComponent<vue976.ExtractPropTypes<{
   className: {
     type: StringConstructor;
     required: true;
@@ -22,7 +22,7 @@ declare const WaveEffect: vue363.DefineComponent<vue363.ExtractPropTypes<{
     type: PropType<WaveProps["colorSource"]>;
     required: false;
   };
-}>, () => vue_jsx_runtime10.JSX.Element | null, {}, {}, {}, vue363.ComponentOptionsMixin, vue363.ComponentOptionsMixin, "finish"[], "finish", vue363.PublicProps, Readonly<vue363.ExtractPropTypes<{
+}>, () => vue_jsx_runtime33.JSX.Element | null, {}, {}, {}, vue976.ComponentOptionsMixin, vue976.ComponentOptionsMixin, "finish"[], "finish", vue976.PublicProps, Readonly<vue976.ExtractPropTypes<{
   className: {
     type: StringConstructor;
     required: true;
@@ -41,7 +41,7 @@ declare const WaveEffect: vue363.DefineComponent<vue363.ExtractPropTypes<{
   };
 }>> & Readonly<{
   onFinish?: ((...args: any[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, vue363.ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, {}, string, vue976.ComponentProvideOptions, true, {}, any>;
 declare const showWaveEffect: ShowWaveEffect;
 //#endregion
 export { WaveEffect, showWaveEffect as default };

package/dist/_util/wave/index.d.ts

@@ -1,5 +1,5 @@
 import { WaveComponent } from "./interface.js";
-import * as vue528 from "vue";
+import * as vue991 from "vue";
 import { SlotsType } from "vue";
 
 //#region src/_util/wave/index.d.ts
@@ -8,14 +8,10 @@ interface WaveProps {
   component?: WaveComponent;
   colorSource?: 'color' | 'backgroundColor' | 'borderColor' | null;
 }
-interface WaveEmits {
-  [key: string]: any;
-}
+interface WaveEmits {}
 interface WaveSlots {
   default?: () => any;
 }
-declare const _default: vue528.DefineSetupFnComponent<WaveProps, WaveEmits, SlotsType<WaveSlots>, WaveProps & {
-  [x: `on${Capitalize<string>}`]: ((...args: any[] | unknown[]) => any) | undefined;
-}, vue528.PublicProps>;
+declare const _default: vue991.DefineSetupFnComponent<WaveProps, WaveEmits, SlotsType<WaveSlots>, WaveProps, vue991.PublicProps>;
 //#endregion
 export { WaveEmits, WaveProps, WaveSlots, _default as default };

package/dist/_util/wave/style.d.ts

@@ -1,10 +1,10 @@
 import { FullToken } from "../../theme/interface/cssinjs-utils.js";
 import "../../theme/internal.js";
-import * as vue66 from "vue";
+import * as vue876 from "vue";
 
 //#region src/_util/wave/style.d.ts
 interface ComponentToken {}
 interface WaveToken extends FullToken<'Wave'> {}
-declare const _default: (prefixCls: vue66.Ref<string>, rootCls?: vue66.Ref<string | undefined>) => vue66.Ref<string, string>;
+declare const _default: (prefixCls: vue876.Ref<string>, rootCls?: vue876.Ref<string | undefined>) => vue876.Ref<string, string>;
 //#endregion
 export { ComponentToken, WaveToken, _default as default };

package/dist/_util/zindexContext.d.ts

@@ -1,13 +1,13 @@
-import * as vue783 from "vue";
+import * as vue573 from "vue";
 import { Ref } from "vue";
 
 //#region src/_util/zindexContext.d.ts
 declare function useZIndexContext(): Ref<number | null | undefined, number | null | undefined>;
 declare function useZIndexProvider(zIndex: Ref<number | undefined>): void;
-declare const ZIndexProvider: vue783.DefineSetupFnComponent<{
+declare const ZIndexProvider: vue573.DefineSetupFnComponent<{
   value: any;
 }, {}, {}, {
   value: any;
-} & {}, vue783.PublicProps>;
+} & {}, vue573.PublicProps>;
 //#endregion
 export { ZIndexProvider, useZIndexContext, useZIndexProvider };

package/dist/affix/index.d.ts

@@ -1,6 +1,6 @@
 import throttleByAnimationFrame from "../_util/throttleByAnimationFrame.js";
 import { ComponentBaseProps } from "../config-provider/context.js";
-import * as vue510 from "vue";
+import * as vue569 from "vue";
 
 //#region src/affix/index.d.ts
 interface AffixProps extends ComponentBaseProps {
@@ -13,7 +13,6 @@ interface AffixProps extends ComponentBaseProps {
 }
 interface AffixEmits {
   change: (affixed: boolean) => void;
-  [key: string]: (...args: any[]) => void;
 }
 interface AffixRef {
   updatePosition: ReturnType<typeof throttleByAnimationFrame>;
@@ -21,10 +20,8 @@ interface AffixRef {
 type InternalAffixProps = AffixProps & {
   onTestUpdatePosition?: any;
 };
-declare const Affix: vue510.DefineSetupFnComponent<InternalAffixProps, AffixEmits, {}, AffixProps & {
+declare const Affix: vue569.DefineSetupFnComponent<InternalAffixProps, AffixEmits, {}, AffixProps & {
   onTestUpdatePosition?: any;
-} & {
-  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
-}, vue510.PublicProps>;
+}, vue569.PublicProps>;
 //#endregion
 export { Affix, Affix as default, AffixEmits, AffixProps, AffixRef };

package/dist/affix/style/index.d.ts

@@ -1,6 +1,6 @@
 import { GetDefaultToken } from "../../theme/interface/cssinjs-utils.js";
 import "../../theme/internal.js";
-import * as vue372 from "vue";
+import * as vue966 from "vue";
 
 //#region src/affix/style/index.d.ts
 interface ComponentToken {
@@ -11,6 +11,6 @@ interface ComponentToken {
   zIndexPopup: number;
 }
 declare const prepareComponentToken: GetDefaultToken<'Affix'>;
-declare const _default: (prefixCls: vue372.Ref<string>, rootCls?: vue372.Ref<string | undefined>) => readonly [vue372.Ref<string, string>, vue372.ComputedRef<string | undefined>];
+declare const _default: (prefixCls: vue966.Ref<string>, rootCls?: vue966.Ref<string | undefined>) => readonly [vue966.Ref<string, string>, vue966.ComputedRef<string | undefined>];
 //#endregion
 export { ComponentToken, _default as default, prepareComponentToken };

package/dist/alert/Alert.d.ts

@@ -1,32 +1,34 @@
 import { SlotsDefineType, VueNode } from "../_util/type.js";
-import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import { SemanticType } from "../_util/hooks/useMergeSemantic.js";
 import "../_util/hooks/index.js";
 import { ClosableType } from "../_util/hooks/useClosable.js";
 import { ComponentBaseProps } from "../config-provider/context.js";
-import * as vue743 from "vue";
+import * as vue757 from "vue";
 import { CSSProperties, SlotsType } from "vue";
 
 //#region src/alert/Alert.d.ts
-interface AlertSemanticClassNames {
-  root?: string;
-  icon?: string;
-  section?: string;
-  title?: string;
-  description?: string;
-  actions?: string;
-  close?: string;
+interface AlertSemanticType {
+  classes: {
+    root?: string;
+    icon?: string;
+    section?: string;
+    title?: string;
+    description?: string;
+    actions?: string;
+    close?: string;
+  };
+  styles: {
+    root?: CSSProperties;
+    icon?: CSSProperties;
+    section?: CSSProperties;
+    title?: CSSProperties;
+    description?: CSSProperties;
+    actions?: CSSProperties;
+    close?: CSSProperties;
+  };
 }
-interface AlertSemanticStyles {
-  root?: CSSProperties;
-  icon?: CSSProperties;
-  section?: CSSProperties;
-  title?: CSSProperties;
-  description?: CSSProperties;
-  actions?: CSSProperties;
-  close?: CSSProperties;
-}
-type AlertClassNamesType = SemanticClassNamesType<AlertProps, AlertSemanticClassNames>;
-type AlertStylesType = SemanticStylesType<AlertProps, AlertSemanticStyles>;
+type AlertClassNamesType = SemanticType<AlertProps, AlertSemanticType['classes']>;
+type AlertStylesType = SemanticType<AlertProps, AlertSemanticType['styles']>;
 interface AlertProps extends ComponentBaseProps {
   /** Type of Alert styles, options:`success`, `info`, `warning`, `error` */
   type?: 'success' | 'info' | 'warning' | 'error';
@@ -68,10 +70,7 @@ interface AlertEmits {
   mouseenter: (e: any) => any;
   mouseleave: (e: any) => any;
   click: (e: any) => any;
-  [key: string]: (e: any) => any;
 }
-declare const Alert: vue743.DefineSetupFnComponent<AlertProps, AlertEmits, SlotsType<AlertSlots>, AlertProps & {
-  [x: `on${Capitalize<string>}`]: ((e: any) => any) | undefined;
-}, vue743.PublicProps>;
+declare const Alert: vue757.DefineSetupFnComponent<AlertProps, AlertEmits, SlotsType<AlertSlots>, AlertProps, vue757.PublicProps>;
 //#endregion
-export { AlertClassNamesType, AlertEmits, AlertProps, AlertSemanticClassNames, AlertSemanticStyles, AlertSlots, AlertStylesType, Alert as default };
+export { AlertClassNamesType, AlertEmits, AlertProps, AlertSemanticType, AlertSlots, AlertStylesType, Alert as default };