antdv-next 0.0.111 → 1.0.0-alpha.2

package/dist/_util/responsiveObserver.js

@@ -0,0 +1,106 @@
+import useToken from "../theme/useToken.js";
+import "../theme/internal.js";
+import { addMediaQueryListener, removeMediaQueryListener } from "./mediaQueryUtil.js";
+import { computed } from "vue";
+
+//#region src/_util/responsiveObserver.ts
+const responsiveArray = [
+	"xxl",
+	"xl",
+	"lg",
+	"md",
+	"sm",
+	"xs"
+];
+function getResponsiveMap(token) {
+	return {
+		xs: `(max-width: ${token.screenXSMax}px)`,
+		sm: `(min-width: ${token.screenSM}px)`,
+		md: `(min-width: ${token.screenMD}px)`,
+		lg: `(min-width: ${token.screenLG}px)`,
+		xl: `(min-width: ${token.screenXL}px)`,
+		xxl: `(min-width: ${token.screenXXL}px)`
+	};
+}
+/**
+* Ensures that the breakpoints token are valid, in good order
+* For each breakpoint : screenMin <= screen <= screenMax and screenMax <= nextScreenMin
+*/
+function validateBreakpoints(token) {
+	const indexableToken = token;
+	const revBreakpoints = [...responsiveArray].reverse();
+	revBreakpoints.forEach((breakpoint, i) => {
+		const breakpointUpper = breakpoint.toUpperCase();
+		const screenMin = `screen${breakpointUpper}Min`;
+		const screen = `screen${breakpointUpper}`;
+		if (!(indexableToken[screenMin] <= indexableToken[screen])) throw new Error(`${screenMin}<=${screen} fails : !(${indexableToken[screenMin]}<=${indexableToken[screen]})`);
+		if (i < revBreakpoints.length - 1) {
+			const screenMax = `screen${breakpointUpper}Max`;
+			if (!(indexableToken[screen] <= indexableToken[screenMax])) throw new Error(`${screen}<=${screenMax} fails : !(${indexableToken[screen]}<=${indexableToken[screenMax]})`);
+			const nextScreenMin = `screen${revBreakpoints[i + 1].toUpperCase()}Min`;
+			if (!(indexableToken[screenMax] <= indexableToken[nextScreenMin])) throw new Error(`${screenMax}<=${nextScreenMin} fails : !(${indexableToken[screenMax]}<=${indexableToken[nextScreenMin]})`);
+		}
+	});
+	return token;
+}
+function matchScreen(screens, screenSizes) {
+	if (!screenSizes) return;
+	for (const breakpoint of responsiveArray) if (screens[breakpoint] && screenSizes?.[breakpoint] !== void 0) return screenSizes[breakpoint];
+}
+function useResponsiveObserver() {
+	const [, token] = useToken();
+	return computed(() => {
+		const responsiveMap = getResponsiveMap(validateBreakpoints(token.value));
+		const subscribers = /* @__PURE__ */ new Map();
+		let subUid = -1;
+		let screens = {};
+		return {
+			responsiveMap,
+			matchHandlers: {},
+			dispatch(pointMap) {
+				screens = pointMap;
+				subscribers.forEach((func) => func(screens));
+				return subscribers.size >= 1;
+			},
+			subscribe(func) {
+				if (!subscribers.size) this.register();
+				subUid += 1;
+				subscribers.set(subUid, func);
+				func(screens);
+				return subUid;
+			},
+			unsubscribe(paramToken) {
+				subscribers.delete(paramToken);
+				if (!subscribers.size) this.unregister();
+			},
+			register() {
+				Object.entries(responsiveMap).forEach(([screen, mediaQuery]) => {
+					const listener = ({ matches }) => {
+						this.dispatch({
+							...screens,
+							[screen]: matches
+						});
+					};
+					const mql = window.matchMedia(mediaQuery);
+					addMediaQueryListener(mql, listener);
+					this.matchHandlers[mediaQuery] = {
+						mql,
+						listener
+					};
+					listener(mql);
+				});
+			},
+			unregister() {
+				Object.values(responsiveMap).forEach((mediaQuery) => {
+					const handler = this.matchHandlers[mediaQuery];
+					removeMediaQueryListener(handler?.mql, handler?.listener);
+				});
+				subscribers.clear();
+			}
+		};
+	});
+}
+var responsiveObserver_default = useResponsiveObserver;
+
+//#endregion
+export { responsiveObserver_default as default, matchScreen, responsiveArray };

package/dist/_util/scrollTo.js

@@ -0,0 +1,24 @@
+import getScroll_default, { isWindow } from "./getScroll.js";
+import { easeInOutCubic } from "./easings.js";
+import raf from "@v-c/util/dist/raf";
+
+//#region src/_util/scrollTo.ts
+function scrollTo(y, options = {}) {
+	const { getContainer = () => window, callback, duration = 450 } = options;
+	const container = getContainer();
+	const scrollTop = getScroll_default(container);
+	const startTime = Date.now();
+	const frameFunc = () => {
+		const time = Date.now() - startTime;
+		const nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+		if (isWindow(container)) container.scrollTo(window.pageXOffset, nextScrollTop);
+		else if (container instanceof Document || container.constructor.name === "HTMLDocument") container.documentElement.scrollTop = nextScrollTop;
+		else container.scrollTop = nextScrollTop;
+		if (time < duration) raf(frameFunc);
+		else if (typeof callback === "function") callback();
+	};
+	raf(frameFunc);
+}
+
+//#endregion
+export { scrollTo as default };

package/dist/_util/statusUtils.d.ts

@@ -0,0 +1,7 @@
+import "../form/FormItem/index.js";
+
+//#region src/_util/statusUtils.d.ts
+declare const _InputStatuses: readonly ["warning", "error", "", "success", "validating"];
+type InputStatus = (typeof _InputStatuses)[number];
+//#endregion
+export { InputStatus };

package/dist/_util/statusUtils.js

@@ -0,0 +1,18 @@
+import { clsx } from "@v-c/util";
+
+//#region src/_util/statusUtils.ts
+function getStatusClassNames(prefixCls, status, hasFeedback) {
+	return clsx({
+		[`${prefixCls}-status-success`]: status === "success",
+		[`${prefixCls}-status-warning`]: status === "warning",
+		[`${prefixCls}-status-error`]: status === "error",
+		[`${prefixCls}-status-validating`]: status === "validating",
+		[`${prefixCls}-has-feedback`]: hasFeedback
+	});
+}
+function getMergedStatus(contextStatus, customStatus) {
+	return customStatus || contextStatus;
+}
+
+//#endregion
+export { getMergedStatus, getStatusClassNames };

package/dist/_util/styleChecker.js

@@ -0,0 +1,9 @@
+import canUseDom from "@v-c/util/dist/Dom/canUseDom";
+import { isStyleSupport } from "@v-c/util/dist/Dom/styleChecker";
+
+//#region src/_util/styleChecker.ts
+const canUseDocElement = () => canUseDom() && window.document?.documentElement;
+const isStyleSupport$1 = isStyleSupport;
+
+//#endregion
+export { canUseDocElement, isStyleSupport$1 as isStyleSupport };

package/dist/_util/throttleByAnimationFrame.js

@@ -0,0 +1,22 @@
+import raf from "@v-c/util/dist/raf";
+
+//#region src/_util/throttleByAnimationFrame.ts
+function throttleByAnimationFrame(fn) {
+	let requestId = null;
+	const later = (args) => () => {
+		requestId = null;
+		fn(...args);
+	};
+	const throttled = (...args) => {
+		if (requestId === null) requestId = raf(later(args));
+	};
+	throttled.cancel = () => {
+		raf.cancel(requestId);
+		requestId = null;
+	};
+	return throttled;
+}
+var throttleByAnimationFrame_default = throttleByAnimationFrame;
+
+//#endregion
+export { throttleByAnimationFrame_default as default };

package/dist/_util/toList.js

@@ -0,0 +1,9 @@
+//#region src/_util/toList.ts
+function toList(candidate, skipEmpty = false) {
+	if (skipEmpty && (candidate === void 0 || candidate === null)) return [];
+	return Array.isArray(candidate) ? candidate : [candidate];
+}
+var toList_default = toList;
+
+//#endregion
+export { toList_default as default };

package/dist/_util/tools.js

@@ -0,0 +1,35 @@
+import { toRef } from "vue";
+import { classNames } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+
+//#region src/_util/tools.ts
+function getSlotPropFn(slots, props, key) {
+	const fn = slots[key] || props[key];
+	if (typeof fn === "function") return fn;
+	return () => [fn];
+}
+function getSlotPropsFnRun(slots, props, key, isNull = true, params) {
+	const fn = getSlotPropFn(slots, props, key);
+	if (typeof fn === "function") {
+		let node = fn?.(params);
+		if (!Array.isArray(node)) node = [node];
+		const nodes = filterEmpty(node).filter((v) => v != null);
+		if (nodes.length) {
+			if (nodes.length === 1) return nodes[0];
+			return nodes;
+		}
+		return isNull ? null : void 0;
+	}
+	return fn;
+}
+function toPropsRefs(obj, ...args) {
+	const _res = {};
+	args.forEach((key) => {
+		_res[key] = toRef(obj, key);
+	});
+	return _res;
+}
+const clsx$1 = classNames;
+
+//#endregion
+export { clsx$1 as clsx, getSlotPropFn, getSlotPropsFnRun, toPropsRefs };

package/dist/_util/transKeys.js

@@ -0,0 +1,18 @@
+//#region src/_util/transKeys.ts
+function groupKeysMap(keys) {
+	const map = /* @__PURE__ */ new Map();
+	keys.forEach((key, index) => {
+		map.set(key, index);
+	});
+	return map;
+}
+function groupDisabledKeysMap(dataSource) {
+	const map = /* @__PURE__ */ new Map();
+	dataSource.forEach(({ disabled, key }, index) => {
+		if (disabled && key !== void 0) map.set(key, index);
+	});
+	return map;
+}
+
+//#endregion
+export { groupDisabledKeysMap, groupKeysMap };

package/dist/_util/type.d.ts

@@ -0,0 +1,15 @@
+import { VNode, VNodeChild } from "vue";
+
+//#region src/_util/type.d.ts
+type AnyObject = Record<string, any>;
+type EmptyObject = Record<never, never>;
+type RenderNodeFn<Args extends any[] = any[]> = (...args: Args) => VNodeChild;
+type VueNode<Args extends any[] = any[]> = RenderNodeFn<Args> | boolean | string | number | null | undefined | VNode;
+interface EmptyEmit {
+  [key: string]: (...args: any[]) => void;
+}
+type SlotsDefineType<T extends Record<string, any> = Record<string, any>> = {
+  default?: () => any;
+} & T;
+//#endregion
+export { AnyObject, EmptyEmit, EmptyObject, RenderNodeFn, SlotsDefineType, VueNode };

package/dist/_util/vueNode.js

@@ -0,0 +1,38 @@
+import { Fragment, Text, cloneVNode, h, isVNode } from "vue";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import "@v-c/util/dist/Children/isFragment";
+
+//#region src/_util/vueNode.ts
+function replaceElement(element, replacement, props) {
+	if (!isVNode(element)) return replacement;
+	return cloneVNode(element, typeof props === "function" ? props(element.props || {}) : props);
+}
+function cloneElement(element, props) {
+	return replaceElement(element, element, props);
+}
+function getVNode(node) {
+	if (typeof node === "function") return node?.();
+	return node;
+}
+function checkRenderNode(node) {
+	if (!node) return;
+	const pureChild = filterEmpty(Array.isArray(node) ? node : [node]);
+	if (pureChild.length > 0) if (pureChild.length === 1) return pureChild[0];
+	else return h(Fragment, null, pureChild);
+}
+function getTextByNode(node) {
+	if (isVNode(node) && node.type === Text) return node.children;
+	else if (typeof node === "object" && node !== null && (typeof node.children === "string" || typeof node.children === "number")) return node.children;
+	return node;
+}
+function getTextNodeArr(nodes) {
+	const res = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		res.push(getTextByNode(node));
+	}
+	return res;
+}
+
+//#endregion
+export { checkRenderNode, cloneElement, getTextByNode, getTextNodeArr, getVNode, replaceElement };

package/dist/_util/warning.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from "vue";
+
+//#region src/_util/warning.d.ts
+
+interface WarningContextProps {
+  /**
+   * @descCN 设置警告等级，设置 `false` 时会将废弃相关信息聚合为单条信息。
+   * @descEN Set the warning level. When set to `false`, discard related information will be aggregated into a single message.
+   * @since 5.10.0
+   */
+  strict?: boolean;
+}
+//#endregion
+export { WarningContextProps };

package/dist/_util/warning.js

@@ -0,0 +1,54 @@
+import { getCurrentInstance, inject, provide, ref } from "vue";
+import rcWarning, { resetWarned } from "@v-c/util/dist/warning";
+
+//#region src/_util/warning.ts
+function noop() {}
+let deprecatedWarnList = null;
+function resetWarned$1() {
+	deprecatedWarnList = null;
+	resetWarned();
+}
+const isDev = process.env.NODE_ENV !== "production";
+let _warning = noop;
+if (isDev) _warning = (valid, component, message) => {
+	rcWarning(valid, `[antd: ${component}] ${message}`);
+	if (isDev) resetWarned$1();
+};
+const warning$1 = _warning;
+const WarningContextKey = Symbol("WarningContext");
+function useWarningProvider(props) {
+	provide(WarningContextKey, props);
+}
+function useWarningContext() {
+	if (!getCurrentInstance()) return {};
+	return inject(WarningContextKey, { strict: ref(true) });
+}
+/**
+* This is a hook but we not named as `useWarning`
+* since this is only used in development.
+* We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+*/
+const devUseWarning = isDev ? (component) => {
+	const { strict } = useWarningContext();
+	const typeWarning = (valid, type, message) => {
+		if (!valid) if (strict?.value === false && type === "deprecated") {
+			const existWarning = deprecatedWarnList;
+			if (!deprecatedWarnList) deprecatedWarnList = {};
+			deprecatedWarnList[component] = deprecatedWarnList[component] || [];
+			if (!deprecatedWarnList[component].includes(message || "")) deprecatedWarnList[component].push(message || "");
+			if (!existWarning) console.warn("[antd] There exists deprecated usage in your code:", deprecatedWarnList);
+		} else warning$1(valid, component, message);
+	};
+	typeWarning.deprecated = (valid, oldProp, newProp, message) => {
+		typeWarning(valid, "deprecated", `\`${oldProp}\` is deprecated. Please use \`${newProp}\` instead.${message ? ` ${message}` : ""}`);
+	};
+	return typeWarning;
+} : () => {
+	const noopWarning = () => {};
+	noopWarning.deprecated = noop;
+	return noopWarning;
+};
+var warning_default = warning$1;
+
+//#endregion
+export { warning_default as default, devUseWarning, isDev, useWarningProvider };

package/dist/_util/wave/WaveEffect.js

@@ -0,0 +1,171 @@
+import { TARGET_CLS } from "./interface.js";
+import { getTargetWaveColor } from "./util.js";
+import { computed, createVNode, defineComponent, nextTick, onBeforeUnmount, onMounted, ref, render, shallowRef, watch } from "vue";
+import { classNames } from "@v-c/util";
+import raf from "@v-c/util/dist/raf";
+
+//#region src/_util/wave/WaveEffect.tsx
+function validateNum(value) {
+	return Number.isNaN(value) ? 0 : value;
+}
+const WaveEffect = /* @__PURE__ */ defineComponent({
+	name: "WaveEffect",
+	inheritAttrs: false,
+	props: {
+		className: {
+			type: String,
+			required: true
+		},
+		target: {
+			type: Object,
+			required: true
+		},
+		component: {
+			type: String,
+			required: false
+		},
+		colorSource: {
+			type: String,
+			required: false
+		}
+	},
+	emits: ["finish"],
+	setup(props, { emit }) {
+		const divRef = shallowRef();
+		const waveColor = ref(null);
+		const borderRadius = ref([
+			0,
+			0,
+			0,
+			0
+		]);
+		const left = ref(0);
+		const top = ref(0);
+		const width = ref(0);
+		const height = ref(0);
+		const enabled = ref(false);
+		const finished = ref(false);
+		const waveStyle = computed(() => {
+			const style = {
+				left: `${left.value}px`,
+				top: `${top.value}px`,
+				width: `${width.value}px`,
+				height: `${height.value}px`,
+				borderRadius: borderRadius.value.map((radius) => `${radius}px`).join(" ")
+			};
+			if (waveColor.value) style["--wave-color"] = waveColor.value;
+			return style;
+		});
+		const isSmallComponent = computed(() => {
+			return (props.component === "Checkbox" || props.component === "Radio") && props.target?.classList.contains(TARGET_CLS);
+		});
+		const classes = computed(() => {
+			return classNames(props.className, { "wave-quick": isSmallComponent.value });
+		});
+		function emitFinish() {
+			if (finished.value) return;
+			finished.value = true;
+			emit("finish");
+		}
+		function syncPos() {
+			const { target } = props;
+			if (!target) return;
+			const nodeStyle = getComputedStyle(target);
+			waveColor.value = getTargetWaveColor(target, props.colorSource);
+			const isStatic = nodeStyle.position === "static";
+			const { borderLeftWidth, borderTopWidth } = nodeStyle;
+			left.value = isStatic ? target.offsetLeft : validateNum(-Number.parseFloat(borderLeftWidth));
+			top.value = isStatic ? target.offsetTop : validateNum(-Number.parseFloat(borderTopWidth));
+			width.value = target.offsetWidth;
+			height.value = target.offsetHeight;
+			const { borderTopLeftRadius, borderTopRightRadius, borderBottomRightRadius, borderBottomLeftRadius } = nodeStyle;
+			borderRadius.value = [
+				validateNum(Number.parseFloat(borderTopLeftRadius)),
+				validateNum(Number.parseFloat(borderTopRightRadius)),
+				validateNum(Number.parseFloat(borderBottomRightRadius)),
+				validateNum(Number.parseFloat(borderBottomLeftRadius))
+			];
+		}
+		function triggerEffect() {
+			const element = divRef.value;
+			if (!element) return;
+			element.classList.remove("wave-motion-appear");
+			element.classList.remove("wave-motion-appear-active");
+			element.offsetHeight;
+			element.classList.add("wave-motion-appear");
+			element.classList.add("wave-motion-appear-active");
+		}
+		const rafId = ref();
+		let resizeObserver;
+		let deadlineId;
+		const handleTransitionEnd = (event) => {
+			if (event.target !== divRef.value) return;
+			if (event.propertyName === "opacity") emitFinish();
+		};
+		watch(() => divRef.value, (newEl, oldEl) => {
+			oldEl?.removeEventListener("transitionend", handleTransitionEnd);
+			newEl?.addEventListener("transitionend", handleTransitionEnd);
+		}, { immediate: true });
+		onMounted(() => {
+			rafId.value = raf(() => {
+				syncPos();
+				enabled.value = true;
+				nextTick(() => {
+					triggerEffect();
+					deadlineId = window.setTimeout(() => {
+						emitFinish();
+					}, 5e3);
+				});
+			});
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver(() => {
+					syncPos();
+				});
+				resizeObserver.observe(props.target);
+			}
+		});
+		onBeforeUnmount(() => {
+			if (rafId.value !== void 0) raf.cancel(rafId.value);
+			resizeObserver?.disconnect();
+			if (deadlineId !== void 0) window.clearTimeout(deadlineId);
+			emitFinish();
+		});
+		return () => {
+			if (!enabled.value) return null;
+			return createVNode("div", {
+				"ref": divRef,
+				"class": classes.value,
+				"style": waveStyle.value
+			}, null);
+		};
+	}
+});
+const showWaveEffect = (target, info) => {
+	const { component } = info;
+	if (component === "Checkbox") {
+		const input = target.querySelector("input");
+		if (input && !input.checked) return;
+	}
+	const holder = (target.ownerDocument ?? document).createElement("div");
+	holder.style.position = "absolute";
+	holder.style.left = "0px";
+	holder.style.top = "0px";
+	target.insertBefore(holder, target.firstChild);
+	let unmounted = false;
+	const destroy = () => {
+		if (unmounted) return;
+		unmounted = true;
+		render(null, holder);
+		holder.remove();
+	};
+	render(createVNode(WaveEffect, {
+		className: info.className,
+		target,
+		component,
+		onFinish: destroy
+	}), holder);
+};
+var WaveEffect_default = showWaveEffect;
+
+//#endregion
+export { WaveEffect_default as default };

package/dist/_util/wave/index.js

@@ -0,0 +1,81 @@
+import { useConfig } from "../../config-provider/context.js";
+import style_default from "./style.js";
+import useWave from "./useWave.js";
+import { cloneVNode, computed, defineComponent, isVNode, onBeforeUnmount, shallowRef, watch } from "vue";
+import { classNames } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import { unrefElement } from "@vueuse/core";
+
+//#region src/_util/wave/index.tsx
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+function isVisible(element) {
+	if (!isBrowser) return false;
+	if (!element) return false;
+	if (element === document.body) return true;
+	if (element.offsetWidth || element.offsetHeight || element.getClientRects().length) return true;
+	const style = getComputedStyle(element);
+	return style.display !== "none" && style.visibility !== "hidden";
+}
+var wave_default = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	const configCtx = useConfig();
+	const containerRef = shallowRef(null);
+	const prefixCls = computed(() => configCtx.value.getPrefixCls("wave"));
+	const hashId = style_default(prefixCls);
+	const colorSource = computed(() => props.colorSource);
+	const showWave = useWave(containerRef, computed(() => classNames(prefixCls.value, hashId.value)), computed(() => props.component), colorSource);
+	const handleClick = (event) => {
+		const node = containerRef.value;
+		if (!node || !isBrowser) return;
+		const target = event.target;
+		if (!isVisible(target)) return;
+		const nodeCls = typeof node.className === "string" ? node.className : String(node.className);
+		if (node.getAttribute?.("disabled") || node.disabled || nodeCls.includes("disabled") && !nodeCls.includes("disabled:") || node.getAttribute?.("aria-disabled") === "true" || nodeCls.includes("-leave")) return;
+		showWave(event);
+	};
+	watch(() => ({
+		node: containerRef.value,
+		disabled: props.disabled
+	}), ({ node, disabled }, _, onCleanup) => {
+		if (!isBrowser) return;
+		if (!node || node.nodeType !== window.Node.ELEMENT_NODE || disabled) return;
+		onCleanup(() => {
+			node?.removeEventListener("click", handleClick, true);
+		});
+		node.addEventListener("click", handleClick, true);
+	}, { immediate: true });
+	onBeforeUnmount(() => {
+		if (!isBrowser) return;
+		containerRef.value?.removeEventListener("click", handleClick, true);
+	});
+	const mergedRef = (el, node) => {
+		const _el = unrefElement(el);
+		if (_el) containerRef.value = _el;
+		if (node.ref) {
+			if (typeof node.ref === "function") node.ref(_el);
+			else if (typeof node.ref === "object" && "value" in node.ref?.r) node.ref.r.value = _el;
+		}
+	};
+	return () => {
+		const children = filterEmpty(slots.default?.() ?? []);
+		if (children.length !== 1) return children;
+		const child = children[0];
+		if (!isVNode(child)) return child;
+		return cloneVNode(child, { ref: (el) => mergedRef(el, child) });
+	};
+}, { props: {
+	disabled: {
+		type: Boolean,
+		required: false
+	},
+	component: {
+		type: String,
+		required: false
+	},
+	colorSource: {
+		type: [String, null],
+		required: false
+	}
+} });
+
+//#endregion
+export { wave_default as default };

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

@@ -0,0 +1,14 @@
+import { GlobalToken } from "../../theme/interface/cssinjs-utils.js";
+import "../../theme/internal.js";
+
+//#region src/_util/wave/interface.d.ts
+type WaveComponent = 'Tag' | 'Button' | 'Checkbox' | 'Radio' | 'Switch' | 'Steps';
+type ShowWaveEffect = (element: HTMLElement, info: {
+  className: string;
+  token: GlobalToken;
+  component?: WaveComponent;
+  event: MouseEvent;
+  hashId: string;
+}) => void;
+//#endregion
+export { ShowWaveEffect };

package/dist/_util/wave/interface.js

@@ -0,0 +1,7 @@
+import { defaultPrefixCls } from "../../config-provider/context.js";
+
+//#region src/_util/wave/interface.ts
+const TARGET_CLS = `${defaultPrefixCls}-wave-target`;
+
+//#endregion
+export { TARGET_CLS };

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

@@ -0,0 +1,7 @@
+import "../../theme/internal.js";
+import "vue";
+
+//#region src/_util/wave/style.d.ts
+interface ComponentToken {}
+//#endregion
+export { ComponentToken };