antdv-next 1.1.0 → 1.1.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 vue526 from "vue";
+import * as vue0 from "vue";
 import { SlotsType } from "vue";
 
 //#region src/_util/ActionButton.d.ts
@@ -20,6 +20,6 @@ interface ActionButtonProps {
 interface ActionButtonSlots {
   default?: () => any;
 }
-declare const ActionButton: vue526.DefineSetupFnComponent<ActionButtonProps, EmptyEmit, SlotsType<ActionButtonSlots>, ActionButtonProps, vue526.PublicProps>;
+declare const ActionButton: vue0.DefineSetupFnComponent<ActionButtonProps, EmptyEmit, SlotsType<ActionButtonSlots>, ActionButtonProps, vue0.PublicProps>;
 //#endregion
 export { ActionButtonProps, ActionButtonSlots, ActionButton as default };

package/dist/_util/ContextIsolator.d.ts

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

package/dist/_util/gapSize.js

@@ -3,6 +3,7 @@ function isPresetSize(size) {
 	return [
 		"small",
 		"middle",
+		"medium",
 		"large"
 	].includes(size);
 }

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

@@ -1,5 +1,5 @@
 import { RenderNodeFn, VueNode } from "../type.js";
-import * as vue811 from "vue";
+import * as vue590 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>): vue811.ComputedRef<readonly [true, vue811.VNode<vue811.RendererNode, vue811.RendererElement, {
+declare function useClosable(propCloseCollection?: Ref<ClosableCollection>, contextCloseCollection?: Ref<ClosableCollection | null>, fallbackCloseCollection?: Ref<FallbackCloseCollection>): vue590.ComputedRef<readonly [true, vue590.VNode<vue590.RendererNode, vue590.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 vue1025 from "vue";
+import * as vue472 from "vue";
 import { CSSProperties, Ref } from "vue";
 
 //#region src/_util/hooks/useMergeSemantic.d.ts
@@ -37,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 [vue1025.ComputedRef<ObjectOnly<ClassNamesType>>, vue1025.ComputedRef<ObjectOnly<StylesType>>];
+}>, schema?: Ref<SemanticSchema>): readonly [vue472.ComputedRef<ObjectOnly<ClassNamesType>>, vue472.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>[]): vue1025.ComputedRef<(T | undefined)[]>;
-declare function useToProps<T>(props: Ref<T>): vue1025.ComputedRef<{
+declare function useToArr<T = any>(...args: Ref<T | undefined>[]): vue472.ComputedRef<(T | undefined)[]>;
+declare function useToProps<T>(props: Ref<T>): vue472.ComputedRef<{
   props: T;
 }>;
 interface RemoveBaseAttributesOptions {

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

@@ -1,4 +1,4 @@
-import * as vue1007 from "vue";
+import * as vue727 from "vue";
 import { Ref } from "vue";
 
 //#region src/_util/hooks/useMergedMask.d.ts
@@ -9,8 +9,8 @@ interface MaskConfig {
 }
 type MaskType = MaskConfig | boolean;
 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 [vue1007.ComputedRef<boolean>, vue1007.ComputedRef<{
+declare function useMergedMask(mask: Ref<MaskType | undefined>, contextMask: Ref<MaskType | undefined>, prefixCls: Ref<string | undefined>, maskClosable?: Ref<boolean | undefined>): readonly [vue727.ComputedRef<boolean>, vue727.ComputedRef<{
   mask: string | undefined;
-}>, vue1007.ComputedRef<boolean>];
+}>, vue727.ComputedRef<boolean>];
 //#endregion
 export { MaskConfig, MaskType, normalizeMaskConfig, useMergedMask };

package/dist/_util/instance.d.ts

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

package/dist/_util/responsiveObserver.d.ts

@@ -1,4 +1,4 @@
-import * as vue148 from "vue";
+import * as vue147 from "vue";
 
 //#region src/_util/responsiveObserver.d.ts
 declare const responsiveArray: readonly ["xxxl", "xxl", "xl", "lg", "md", "sm", "xs"];
@@ -21,6 +21,6 @@ interface ResponsiveObserverType {
     listener: (this: MediaQueryList, ev: MediaQueryListEvent) => void;
   }>;
 }
-declare function useResponsiveObserver(): vue148.ComputedRef<ResponsiveObserverType>;
+declare function useResponsiveObserver(): vue147.ComputedRef<ResponsiveObserverType>;
 //#endregion
 export { Breakpoint, BreakpointMap, ScreenMap, ScreenSizeMap, useResponsiveObserver 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): "" | "error" | "success" | "warning" | "validating" | undefined;
 //#endregion
 export { InputStatus, getMergedStatus, getStatusClassNames };

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

@@ -0,0 +1,9 @@
+import { VNode } from "vue";
+
+//#region src/_util/vnode/index.d.ts
+declare function resolveVNodeProps(vnode: VNode, name?: string, markerKey?: string): {
+  [x: string]: any;
+};
+declare function resolveSlotsNode<T = any>(slots: Record<string, any>, slotName: string, name?: string, markerKey?: string): T[];
+//#endregion
+export { resolveSlotsNode, resolveVNodeProps };

package/dist/_util/vnode/index.js

@@ -0,0 +1,154 @@
+import { Comment } from "vue";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+
+//#region src/_util/vnode/index.ts
+const EMPTY_OBJ = Object.freeze({});
+function hasOwn(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isFunction(value) {
+	return typeof value === "function";
+}
+function camelize(str) {
+	return str.replace(/-(\w)/g, (_, c) => c ? c.toUpperCase() : "");
+}
+function hyphenate(str) {
+	return str.replace(/\B([A-Z])/g, "-$1").toLowerCase();
+}
+function isBooleanType(type) {
+	return isFunction(type) && type.name === "Boolean";
+}
+function isStringType(type) {
+	return isFunction(type) && type.name === "String";
+}
+function isReservedProp(key) {
+	return key === "key" || key === "ref";
+}
+function isComponentVNode(vnode) {
+	return typeof vnode.type === "object" || typeof vnode.type === "function";
+}
+function getVNodeComponentName(vnode) {
+	if (!isComponentVNode(vnode)) return;
+	const type = vnode.type;
+	return type.name || type.__name || type.displayName;
+}
+function isTargetComponent(vnode, name) {
+	return getVNodeComponentName(vnode) === name;
+}
+function hasTargetMarker(vnode, markerKey) {
+	if (!isComponentVNode(vnode)) return false;
+	return Boolean(vnode.type?.[markerKey]);
+}
+function normalizePropsOptions(vnode) {
+	if (!isComponentVNode(vnode)) return [];
+	const raw = vnode.type.props;
+	if (!raw) return [];
+	const normalized = {};
+	const needCastKeys = [];
+	if (Array.isArray(raw)) raw.forEach((key) => {
+		if (typeof key !== "string") return;
+		normalized[camelize(key)] = {};
+	});
+	else if (typeof raw === "object") Object.keys(raw).forEach((key) => {
+		const normalizedKey = camelize(key);
+		const opt = raw[key];
+		const prop = Array.isArray(opt) || isFunction(opt) ? { type: opt } : opt ? { ...opt } : {};
+		const propType = prop.type;
+		let shouldCast = false;
+		let shouldCastTrue = true;
+		if (Array.isArray(propType)) for (let index = 0; index < propType.length; index += 1) {
+			const type = propType[index];
+			if (isBooleanType(type)) {
+				shouldCast = true;
+				break;
+			}
+			if (isStringType(type)) shouldCastTrue = false;
+		}
+		else shouldCast = isBooleanType(propType);
+		prop.shouldCast = shouldCast;
+		prop.shouldCastTrue = shouldCastTrue;
+		normalized[normalizedKey] = prop;
+		if (shouldCast || hasOwn(prop, "default")) needCastKeys.push(normalizedKey);
+	});
+	return [normalized, needCastKeys];
+}
+function resolvePropValue(options, props, key, value, isAbsent) {
+	const opt = options[key];
+	if (!opt) return value;
+	const hasDefault = hasOwn(opt, "default");
+	if (hasDefault && value === void 0) {
+		const defaultValue = opt.default;
+		if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) value = defaultValue(props);
+		else value = defaultValue;
+	}
+	if (opt.shouldCast) {
+		if (isAbsent && !hasDefault) value = false;
+		else if (opt.shouldCastTrue && (value === "" || value === hyphenate(key))) value = true;
+	}
+	return value;
+}
+function normalizeSlotValue(value) {
+	const nodes = filterEmpty(value).filter((node) => node !== void 0 && node !== null && (typeof node !== "object" || node.type !== Comment));
+	if (nodes.length === 0) return;
+	return nodes.length === 1 ? nodes[0] : nodes;
+}
+function resolveVNodeProps(vnode, name, markerKey) {
+	if (markerKey && !hasTargetMarker(vnode, markerKey)) return {};
+	if (!markerKey && name && !isTargetComponent(vnode, name)) return {};
+	const rawProps = vnode.props || EMPTY_OBJ;
+	const normalizedPropsOptions = normalizePropsOptions(vnode);
+	const resolvedProps = {};
+	const attrs = {};
+	if (normalizedPropsOptions.length > 0) {
+		const [options, needCastKeys] = normalizedPropsOptions;
+		const needCastKeySet = new Set(needCastKeys);
+		const rawCastValues = {};
+		Object.keys(rawProps).forEach((key) => {
+			if (isReservedProp(key)) return;
+			const value = rawProps[key];
+			const camelKey = camelize(key);
+			if (hasOwn(options, camelKey)) if (!needCastKeySet.has(camelKey)) resolvedProps[camelKey] = value;
+			else rawCastValues[camelKey] = value;
+			else attrs[key] = value;
+		});
+		needCastKeys.forEach((key) => {
+			resolvedProps[key] = resolvePropValue(options, resolvedProps, key, rawCastValues[key], !hasOwn(rawCastValues, key));
+		});
+	} else Object.keys(rawProps).forEach((key) => {
+		if (isReservedProp(key)) return;
+		attrs[key] = rawProps[key];
+	});
+	const result = {
+		...attrs,
+		...resolvedProps
+	};
+	if (result.className === void 0 && result.class !== void 0) result.className = result.class;
+	if (result.class === void 0 && result.className !== void 0) result.class = result.className;
+	if (vnode.key != null && result.key === void 0) result.key = vnode.key;
+	if (typeof vnode.children === "object" && vnode.children && !Array.isArray(vnode.children)) Object.keys(vnode.children).forEach((slotName) => {
+		if (slotName === "_") return;
+		const slotFn = vnode.children[slotName];
+		if (!isFunction(slotFn)) return;
+		const value = normalizeSlotValue(slotFn());
+		if (value === void 0) return;
+		if (slotName === "default") {
+			result.children = value;
+			return;
+		}
+		result[camelize(slotName)] = value;
+	});
+	return result;
+}
+function resolveSlotsNode(slots, slotName, name, markerKey) {
+	if (!slots[slotName]) return [];
+	const nodes = filterEmpty(slots?.[slotName]?.() ?? []).filter((node) => node !== void 0 && node !== null && node.type !== Comment);
+	if (nodes.length === 0) return [];
+	const targetNodes = markerKey ? nodes.filter((node) => hasTargetMarker(node, markerKey)) : name ? nodes.filter((node) => isTargetComponent(node, name)) : nodes;
+	return targetNodes.map((node) => resolveVNodeProps(node, void 0, markerKey)).filter((item, index) => {
+		if (Object.keys(item).length > 0) return true;
+		return isComponentVNode(targetNodes[index]);
+	});
+}
+
+//#endregion
+export { resolveSlotsNode, resolveVNodeProps };

package/dist/_util/vueNode.d.ts

@@ -1,16 +1,16 @@
 import { AnyObject, VueNode } from "./type.js";
-import * as vue15 from "vue";
+import * as vue322 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 | vue15.VNode<vue15.RendererNode, vue15.RendererElement, {
+declare function replaceElement(element: VNodeChild, replacement: VNodeChild, props?: RenderProps): string | number | boolean | void | vue322.VNode<vue322.RendererNode, vue322.RendererElement, {
   [key: string]: any;
-}> | vue15.VNodeArrayChildren | null;
-declare function cloneElement(element: VNodeChild, props?: RenderProps): string | number | boolean | void | vue15.VNode<vue15.RendererNode, vue15.RendererElement, {
+}> | vue322.VNodeArrayChildren | null;
+declare function cloneElement(element: VNodeChild, props?: RenderProps): string | number | boolean | void | vue322.VNode<vue322.RendererNode, vue322.RendererElement, {
   [key: string]: any;
-}> | vue15.VNodeArrayChildren | null;
+}> | vue322.VNodeArrayChildren | null;
 declare function getVNode(node: VueNode): VNodeChild;
 declare function checkRenderNode(node: any): any;
 declare function getTextByNode(node: any): any;

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

@@ -1,11 +1,11 @@
 import { ShowWaveEffect, WaveComponent } from "./interface.js";
 import { WaveProps } from "./index.js";
-import * as vue552 from "vue";
+import * as vue847 from "vue";
 import { PropType } from "vue";
-import * as vue_jsx_runtime23 from "vue/jsx-runtime";
+import * as vue_jsx_runtime30 from "vue/jsx-runtime";
 
 //#region src/_util/wave/WaveEffect.d.ts
-declare const WaveEffect: vue552.DefineComponent<vue552.ExtractPropTypes<{
+declare const WaveEffect: vue847.DefineComponent<vue847.ExtractPropTypes<{
   className: {
     type: StringConstructor;
     required: true;
@@ -22,7 +22,7 @@ declare const WaveEffect: vue552.DefineComponent<vue552.ExtractPropTypes<{
     type: PropType<WaveProps["colorSource"]>;
     required: false;
   };
-}>, () => vue_jsx_runtime23.JSX.Element | null, {}, {}, {}, vue552.ComponentOptionsMixin, vue552.ComponentOptionsMixin, "finish"[], "finish", vue552.PublicProps, Readonly<vue552.ExtractPropTypes<{
+}>, () => vue_jsx_runtime30.JSX.Element | null, {}, {}, {}, vue847.ComponentOptionsMixin, vue847.ComponentOptionsMixin, "finish"[], "finish", vue847.PublicProps, Readonly<vue847.ExtractPropTypes<{
   className: {
     type: StringConstructor;
     required: true;
@@ -41,7 +41,7 @@ declare const WaveEffect: vue552.DefineComponent<vue552.ExtractPropTypes<{
   };
 }>> & Readonly<{
   onFinish?: ((...args: any[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, vue552.ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, {}, string, vue847.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 { WaveColorSource, WaveComponent } from "./interface.js";
-import * as vue580 from "vue";
+import * as vue856 from "vue";
 import { SlotsType } from "vue";
 
 //#region src/_util/wave/index.d.ts
@@ -13,6 +13,6 @@ interface WaveEmitsProps {}
 interface WaveSlots {
   default?: () => any;
 }
-declare const _default: vue580.DefineSetupFnComponent<WaveProps, WaveEmits, SlotsType<WaveSlots>, WaveProps, vue580.PublicProps>;
+declare const _default: vue856.DefineSetupFnComponent<WaveProps, WaveEmits, SlotsType<WaveSlots>, WaveProps, vue856.PublicProps>;
 //#endregion
 export { WaveEmits, WaveEmitsProps, 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 vue348 from "vue";
+import * as vue960 from "vue";
 
 //#region src/_util/wave/style.d.ts
 interface ComponentToken {}
 interface WaveToken extends FullToken<'Wave'> {}
-declare const _default: (prefixCls: vue348.Ref<string>, rootCls?: vue348.Ref<string | undefined>) => vue348.Ref<string, string>;
+declare const _default: (prefixCls: vue960.Ref<string>, rootCls?: vue960.Ref<string | undefined>) => vue960.Ref<string, string>;
 //#endregion
 export { ComponentToken, WaveToken, _default as default };

package/dist/_util/zindexContext.d.ts

@@ -1,13 +1,13 @@
-import * as vue520 from "vue";
+import * as vue273 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: vue520.DefineSetupFnComponent<{
+declare const ZIndexProvider: vue273.DefineSetupFnComponent<{
   value: any;
 }, {}, {}, {
   value: any;
-} & {}, vue520.PublicProps>;
+} & {}, vue273.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 vue2 from "vue";
+import * as vue347 from "vue";
 
 //#region src/affix/index.d.ts
 interface AffixProps extends ComponentBaseProps, AffixEmitsProps {
@@ -23,8 +23,8 @@ interface AffixRef {
 type InternalAffixProps = AffixProps & {
   onTestUpdatePosition?: any;
 };
-declare const Affix: vue2.DefineSetupFnComponent<InternalAffixProps, AffixEmits, {}, AffixProps & {
+declare const Affix: vue347.DefineSetupFnComponent<InternalAffixProps, AffixEmits, {}, AffixProps & {
   onTestUpdatePosition?: any;
-}, vue2.PublicProps>;
+}, vue347.PublicProps>;
 //#endregion
 export { Affix, Affix as default, AffixEmits, AffixEmitsProps, 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 vue1032 from "vue";
+import * as vue971 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: vue1032.Ref<string>, rootCls?: vue1032.Ref<string | undefined>) => readonly [vue1032.Ref<string, string>, vue1032.ComputedRef<string | undefined>];
+declare const _default: (prefixCls: vue971.Ref<string>, rootCls?: vue971.Ref<string | undefined>) => readonly [vue971.Ref<string, string>, vue971.ComputedRef<string | undefined>];
 //#endregion
 export { ComponentToken, _default as default, prepareComponentToken };

package/dist/alert/Alert.d.ts

@@ -3,7 +3,7 @@ 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 vue4 from "vue";
+import * as vue364 from "vue";
 import { CSSProperties, SlotsType } from "vue";
 
 //#region src/alert/Alert.d.ts
@@ -77,6 +77,6 @@ interface AlertEmitsProps {
   onMouseleave?: AlertEmits['mouseleave'];
   onClick?: AlertEmits['click'];
 }
-declare const Alert: vue4.DefineSetupFnComponent<AlertProps, AlertEmits, SlotsType<AlertSlots>, AlertProps, vue4.PublicProps>;
+declare const Alert: vue364.DefineSetupFnComponent<AlertProps, AlertEmits, SlotsType<AlertSlots>, AlertProps, vue364.PublicProps>;
 //#endregion
 export { AlertClassNamesType, AlertEmits, AlertEmitsProps, AlertProps, AlertSemanticType, AlertSlots, AlertStylesType, Alert as default };

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

@@ -1,7 +1,7 @@
 import { FullToken, GetDefaultToken } from "../../theme/interface/cssinjs-utils.js";
 import { GenerateStyle } from "../../theme/interface/index.js";
 import "../../theme/internal.js";
-import * as vue1057 from "vue";
+import * as vue1010 from "vue";
 import { CSSProperties } from "vue";
 import { CSSObject } from "@antdv-next/cssinjs";
 
@@ -28,6 +28,6 @@ declare const genBaseStyle: GenerateStyle<AlertToken, CSSObject>;
 declare const genTypeStyle: GenerateStyle<AlertToken, CSSObject>;
 declare const genActionStyle: GenerateStyle<AlertToken, CSSObject>;
 declare const prepareComponentToken: GetDefaultToken<'Alert'>;
-declare const _default: (prefixCls: vue1057.Ref<string>, rootCls?: vue1057.Ref<string | undefined>) => readonly [vue1057.Ref<string, string>, vue1057.ComputedRef<string | undefined>];
+declare const _default: (prefixCls: vue1010.Ref<string>, rootCls?: vue1010.Ref<string | undefined>) => readonly [vue1010.Ref<string, string>, vue1010.ComputedRef<string | undefined>];
 //#endregion
 export { ComponentToken, _default as default, genActionStyle, genBaseStyle, genTypeStyle, prepareComponentToken };

package/dist/anchor/Anchor.d.ts

@@ -4,7 +4,7 @@ import "../_util/hooks/index.js";
 import { AffixProps } from "../affix/index.js";
 import { AnchorLinkBaseProps } from "./AnchorLink.js";
 import { ComponentBaseProps } from "../config-provider/context.js";
-import * as vue6 from "vue";
+import * as vue351 from "vue";
 import { CSSProperties, SlotsType, VNodeChild } from "vue";
 import { Key } from "@v-c/util/dist/type";
 
@@ -70,6 +70,6 @@ interface AntAnchor {
   }) => void;
   direction: AnchorDirection;
 }
-declare const Anchor: vue6.DefineSetupFnComponent<AnchorProps, AnchorEmits, SlotsType<AnchorSlots>, AnchorProps, vue6.PublicProps>;
+declare const Anchor: vue351.DefineSetupFnComponent<AnchorProps, AnchorEmits, SlotsType<AnchorSlots>, AnchorProps, vue351.PublicProps>;
 //#endregion
 export { AnchorClassNamesType, AnchorContainer, AnchorDirection, AnchorEmits, AnchorEmitsProps, AnchorLinkItemProps, AnchorProps, AnchorSemanticClassNames, AnchorSemanticStyles, AnchorSlots, AnchorStylesType, AntAnchor, Anchor as default };

package/dist/anchor/AnchorLink.d.ts

@@ -1,6 +1,6 @@
 import { VueNode } from "../_util/type.js";
 import { ComponentBaseProps } from "../config-provider/context.js";
-import * as vue665 from "vue";
+import * as vue423 from "vue";
 
 //#region src/anchor/AnchorLink.d.ts
 interface AnchorLinkBaseProps extends ComponentBaseProps {
@@ -19,6 +19,6 @@ interface AnchorLinkEmitsProps {
   onClick?: AnchorLinkEmits['click'];
 }
 interface AnchorLinkProps extends AnchorLinkBaseProps, AnchorLinkEmitsProps {}
-declare const AnchorLink: vue665.DefineSetupFnComponent<AnchorLinkProps, AnchorLinkEmits, {}, AnchorLinkProps, vue665.PublicProps>;
+declare const AnchorLink: vue423.DefineSetupFnComponent<AnchorLinkProps, AnchorLinkEmits, {}, AnchorLinkProps, vue423.PublicProps>;
 //#endregion
 export { AnchorLinkBaseProps, AnchorLinkEmits, AnchorLinkEmitsProps, AnchorLinkProps, AnchorLink as default };

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

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