antdv-next 0.0.111 → 1.0.0-alpha.1

package/dist/_util/wave/style.js

@@ -0,0 +1,28 @@
+import { genComponentStyleHook } from "../../theme/util/genStyleUtils.js";
+import "../../theme/internal.js";
+
+//#region src/_util/wave/style.ts
+const genWaveStyle = (token) => {
+	const { componentCls, colorPrimary } = token;
+	return { [componentCls]: {
+		"position": "absolute",
+		"background": "transparent",
+		"pointerEvents": "none",
+		"boxSizing": "border-box",
+		"color": `var(--wave-color, ${colorPrimary})`,
+		"boxShadow": `0 0 0 0 currentcolor`,
+		"opacity": .2,
+		"&.wave-motion-appear": {
+			"transition": [`box-shadow 0.4s ${token.motionEaseOutCirc}`, `opacity 2s ${token.motionEaseOutCirc}`].join(","),
+			"&-active": {
+				boxShadow: `0 0 0 6px currentcolor`,
+				opacity: 0
+			},
+			"&.wave-quick": { transition: [`box-shadow ${token.motionDurationSlow} ${token.motionEaseInOut}`, `opacity ${token.motionDurationSlow} ${token.motionEaseInOut}`].join(",") }
+		}
+	} };
+};
+var style_default = genComponentStyleHook("Wave", genWaveStyle);
+
+//#endregion
+export { style_default as default };

package/dist/_util/wave/useWave.js

@@ -0,0 +1,42 @@
+import { useConfig } from "../../config-provider/context.js";
+import useToken from "../../theme/useToken.js";
+import { TARGET_CLS } from "./interface.js";
+import WaveEffect_default from "./WaveEffect.js";
+import { onBeforeUnmount, ref, unref } from "vue";
+import raf from "@v-c/util/dist/raf";
+
+//#region src/_util/wave/useWave.ts
+function useWave(nodeRef, className, component, colorSource) {
+	const configCtx = useConfig();
+	const [, token, hashId] = useToken();
+	const showWave = (event) => {
+		const node = nodeRef.value;
+		if (!node) return;
+		const waveConfig = configCtx.value.wave;
+		if (waveConfig?.disabled) return;
+		const targetNode = node.querySelector(`.${TARGET_CLS}`) || node;
+		const { showEffect } = waveConfig ?? {};
+		(showEffect || WaveEffect_default)(targetNode, {
+			className: unref(className),
+			token: token.value,
+			component: unref(component) ?? void 0,
+			event,
+			hashId: hashId.value,
+			colorSource: colorSource ? unref(colorSource) : void 0
+		});
+	};
+	const rafId = ref();
+	const showDebounceWave = (event) => {
+		if (rafId.value !== void 0) raf.cancel(rafId.value);
+		rafId.value = raf(() => {
+			showWave(event);
+		});
+	};
+	onBeforeUnmount(() => {
+		if (rafId.value !== void 0) raf.cancel(rafId.value);
+	});
+	return showDebounceWave;
+}
+
+//#endregion
+export { useWave as default };

package/dist/_util/wave/util.js

@@ -0,0 +1,17 @@
+//#region src/_util/wave/util.ts
+function isValidWaveColor(color) {
+	return !!color && color !== "#fff" && color !== "#ffffff" && color !== "rgb(255, 255, 255)" && color !== "rgba(255, 255, 255, 1)" && !/rgba\((?:\d*, ){3}0\)/.test(color) && color !== "transparent" && color !== "canvastext";
+}
+function getTargetWaveColor(node, colorSource = null) {
+	const style = getComputedStyle(node);
+	const { borderTopColor, borderColor, backgroundColor } = style;
+	if (colorSource && isValidWaveColor(style[colorSource])) return style[colorSource];
+	return [
+		borderTopColor,
+		borderColor,
+		backgroundColor
+	].find(isValidWaveColor) ?? null;
+}
+
+//#endregion
+export { getTargetWaveColor };

package/dist/_util/zindexContext.js

@@ -0,0 +1,21 @@
+import { computed, defineComponent, inject, provide, ref } from "vue";
+
+//#region src/_util/zindexContext.ts
+const ZIndexContextKey = Symbol("ZIndexContextKey");
+function useZIndexContext() {
+	return inject(ZIndexContextKey, ref(void 0));
+}
+function useZIndexProvider(zIndex) {
+	provide(ZIndexContextKey, zIndex);
+}
+const ZIndexProvider = defineComponent((props, { slots }) => {
+	useZIndexProvider(computed(() => {
+		return props.value;
+	}));
+	return () => {
+		return slots?.default?.();
+	};
+}, { props: ["value"] });
+
+//#endregion
+export { ZIndexProvider, useZIndexContext };

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export };

package/dist/affix/index.d.ts

@@ -0,0 +1,25 @@
+import { ComponentBaseProps } from "../config-provider/context.js";
+import * as vue61 from "vue";
+
+//#region src/affix/index.d.ts
+interface AffixProps extends ComponentBaseProps {
+  /** Triggered when the specified offset is reached from the top of the window */
+  offsetTop?: number;
+  /** Triggered when the specified offset is reached from the bottom of the window */
+  offsetBottom?: number;
+  /** Set the element that Affix needs to listen to its scroll event, the value is a function that returns the corresponding DOM element */
+  target?: () => Window | HTMLElement | null;
+}
+interface AffixEmits {
+  [key: string]: any;
+}
+type InternalAffixProps = AffixProps & {
+  onTestUpdatePosition?: any;
+};
+declare const Affix: vue61.DefineSetupFnComponent<InternalAffixProps, AffixEmits, {}, AffixProps & {
+  onTestUpdatePosition?: any;
+} & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[] | unknown[]) => any) | undefined;
+}, vue61.PublicProps>;
+//#endregion
+export { Affix, AffixProps };

package/dist/affix/index.js

@@ -0,0 +1,212 @@
+import throttleByAnimationFrame_default from "../_util/throttleByAnimationFrame.js";
+import { useConfig } from "../config-provider/context.js";
+import style_default from "./style/index.js";
+import { getFixedBottom, getFixedTop, getTargetRect } from "./utils.js";
+import { computed, createVNode, defineComponent, isVNode, mergeDefaults, mergeProps, nextTick, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import { classNames } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import { unrefElement, useResizeObserver } from "@vueuse/core";
+
+//#region src/affix/index.tsx
+const TRIGGER_EVENTS = [
+	"resize",
+	"scroll",
+	"touchstart",
+	"touchmove",
+	"touchend",
+	"pageshow",
+	"load"
+];
+function getDefaultTarget() {
+	return typeof window !== "undefined" ? window : null;
+}
+const AFFIX_STATUS_NONE = 0;
+const AFFIX_STATUS_PREPARE = 1;
+const affixDefaultProps = {};
+const Affix = /* @__PURE__ */ defineComponent((props, { slots, attrs, expose, emit }) => {
+	const configContext = useConfig();
+	const affixPrefixCls = computed(() => configContext.value.getPrefixCls("affix", props.prefixCls));
+	const lastAffix = shallowRef(false);
+	const affixStyle = shallowRef();
+	const placeholderStyle = shallowRef();
+	const status = shallowRef(AFFIX_STATUS_NONE);
+	const prevTarget = shallowRef(null);
+	const prevListener = shallowRef(null);
+	const placeholderNodeRef = shallowRef();
+	const fixedNodeRef = shallowRef();
+	const contextRef = shallowRef();
+	const timer = shallowRef(null);
+	const targetFunc = computed(() => props.target ?? configContext.value.getTargetContainer ?? getDefaultTarget);
+	const internalOffsetTop = computed(() => {
+		const { offsetTop, offsetBottom } = props;
+		return offsetBottom === void 0 && offsetTop === void 0 ? 0 : offsetTop;
+	});
+	const measure = () => {
+		if (status.value !== AFFIX_STATUS_PREPARE || !fixedNodeRef.value || !placeholderNodeRef.value || !targetFunc.value) return;
+		const targetNode = targetFunc.value();
+		if (targetNode) {
+			const newState = { status: AFFIX_STATUS_NONE };
+			const placeholderRect = getTargetRect(placeholderNodeRef.value);
+			if (placeholderRect.top === 0 && placeholderRect.left === 0 && placeholderRect.width === 0 && placeholderRect.height === 0) return;
+			const targetRect = getTargetRect(targetNode);
+			const fixedTop = getFixedTop(placeholderRect, targetRect, internalOffsetTop.value);
+			const fixedBottom = getFixedBottom(placeholderRect, targetRect, props.offsetBottom);
+			if (fixedTop !== void 0) {
+				newState.affixStyle = {
+					position: "fixed",
+					top: `${fixedTop}px`,
+					width: `${placeholderRect.width}px`,
+					height: `${placeholderRect.height}px`
+				};
+				newState.placeholderStyle = {
+					width: `${placeholderRect.width}px`,
+					height: `${placeholderRect.height}px`
+				};
+			} else if (fixedBottom !== void 0) {
+				newState.affixStyle = {
+					position: "fixed",
+					bottom: `${fixedBottom}px`,
+					width: `${placeholderRect.width}px`,
+					height: `${placeholderRect.height}px`
+				};
+				newState.placeholderStyle = {
+					width: `${placeholderRect.width}px`,
+					height: `${placeholderRect.height}px`
+				};
+			}
+			newState.lastAffix = !!newState.affixStyle;
+			if (lastAffix.value !== newState.lastAffix) emit("change", newState.lastAffix);
+			status.value = newState.status;
+			affixStyle.value = newState.affixStyle;
+			placeholderStyle.value = newState.placeholderStyle;
+			lastAffix.value = newState.lastAffix;
+		}
+	};
+	const prepareMeasure = () => {
+		status.value = AFFIX_STATUS_PREPARE;
+		measure();
+	};
+	const updatePosition = throttleByAnimationFrame_default(() => {
+		prepareMeasure();
+	});
+	const lazyUpdatePosition = throttleByAnimationFrame_default(() => {
+		if (targetFunc.value && affixStyle.value) {
+			const targetNode = targetFunc.value();
+			if (targetNode && placeholderNodeRef.value) {
+				const targetRect = getTargetRect(targetNode);
+				const placeholderRect = getTargetRect(placeholderNodeRef.value);
+				const fixedTop = getFixedTop(placeholderRect, targetRect, internalOffsetTop.value);
+				const fixedBottom = getFixedBottom(placeholderRect, targetRect, props.offsetBottom);
+				if (fixedTop !== void 0 && affixStyle.value.top === fixedTop || fixedBottom !== void 0 && affixStyle.value.bottom === fixedBottom) return;
+			}
+		}
+		prepareMeasure();
+	});
+	const addListeners = () => {
+		const listenerTarget = targetFunc.value?.();
+		if (!listenerTarget) return;
+		TRIGGER_EVENTS.forEach((eventName) => {
+			if (prevListener.value) prevTarget.value?.removeEventListener(eventName, prevListener.value);
+			listenerTarget?.addEventListener(eventName, lazyUpdatePosition);
+		});
+		prevTarget.value = listenerTarget;
+		prevListener.value = lazyUpdatePosition;
+	};
+	const removeListeners = () => {
+		const newTarget = targetFunc.value?.();
+		TRIGGER_EVENTS.forEach((eventName) => {
+			newTarget?.removeEventListener(eventName, lazyUpdatePosition);
+			if (prevListener.value) prevTarget.value?.removeEventListener(eventName, prevListener.value);
+		});
+		updatePosition.cancel();
+		lazyUpdatePosition.cancel();
+	};
+	expose({ updatePosition });
+	onMounted(() => {
+		timer.value = setTimeout(addListeners);
+	});
+	onBeforeUnmount(() => {
+		if (timer.value) {
+			clearTimeout(timer.value);
+			timer.value = null;
+		}
+		removeListeners();
+	});
+	watch([
+		() => props.target,
+		affixStyle,
+		lastAffix,
+		() => props.offsetTop,
+		() => props.offsetBottom
+	], async (_new, _old, onCleanup) => {
+		await nextTick();
+		addListeners();
+		onCleanup(removeListeners);
+	});
+	watch([
+		() => props.target,
+		() => props.offsetTop,
+		() => props.offsetBottom
+	], async () => {
+		await nextTick();
+		updatePosition();
+	});
+	const [hashId, cssVarCls] = style_default(affixPrefixCls);
+	useResizeObserver(placeholderNodeRef, () => {
+		updatePosition();
+	});
+	useResizeObserver(contextRef, () => {
+		updatePosition();
+	});
+	return () => {
+		const { rootClass } = props;
+		const mergedCls = classNames({ [classNames(rootClass, hashId.value, affixPrefixCls.value, cssVarCls.value)]: affixStyle.value });
+		const node = filterEmpty(slots?.default?.() ?? [])?.[0];
+		let childNode = null;
+		if (isVNode(node)) childNode = createVNode(node, { ref: (el) => {
+			const _el = unrefElement(el);
+			if (_el) contextRef.value = _el;
+		} });
+		return createVNode("div", mergeProps(attrs, { "ref": placeholderNodeRef }), [affixStyle.value && createVNode("div", {
+			"style": placeholderStyle.value,
+			"aria-hidden": "true"
+		}, null), createVNode("div", {
+			"class": mergedCls,
+			"ref": fixedNodeRef,
+			"style": affixStyle.value
+		}, [childNode])]);
+	};
+}, {
+	props: /* @__PURE__ */ mergeDefaults({
+		offsetTop: {
+			type: Number,
+			required: false
+		},
+		offsetBottom: {
+			type: Number,
+			required: false
+		},
+		target: {
+			type: Function,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		},
+		onTestUpdatePosition: { required: false }
+	}, affixDefaultProps),
+	name: "AAffix",
+	inheritAttrs: false
+});
+Affix.install = (app) => {
+	app.component(Affix.name, Affix);
+};
+var affix_default = Affix;
+
+//#endregion
+export { Affix, affix_default as default };

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

@@ -0,0 +1,13 @@
+import "../../theme/internal.js";
+import "vue";
+
+//#region src/affix/style/index.d.ts
+interface ComponentToken {
+  /**
+   * @desc 弹出层的 z-index
+   * @descEN z-index of popup
+   */
+  zIndexPopup: number;
+}
+//#endregion
+export { ComponentToken };

package/dist/affix/style/index.js

@@ -0,0 +1,16 @@
+import { genStyleHooks } from "../../theme/util/genStyleUtils.js";
+import "../../theme/internal.js";
+
+//#region src/affix/style/index.ts
+const genSharedAffixStyle = (token) => {
+	const { componentCls } = token;
+	return { [componentCls]: {
+		position: "fixed",
+		zIndex: token.zIndexPopup
+	} };
+};
+const prepareComponentToken = (token) => ({ zIndexPopup: token.zIndexBase + 10 });
+var style_default = genStyleHooks("Affix", genSharedAffixStyle, prepareComponentToken);
+
+//#endregion
+export { style_default as default };

package/dist/affix/utils.js

@@ -0,0 +1,16 @@
+//#region src/affix/utils.ts
+function getTargetRect(target) {
+	return target !== window ? target.getBoundingClientRect() : {
+		top: 0,
+		bottom: window.innerHeight
+	};
+}
+function getFixedTop(placeholderRect, targetRect, offsetTop) {
+	if (offsetTop !== void 0 && Math.round(targetRect.top) > Math.round(placeholderRect.top) - offsetTop) return offsetTop + targetRect.top;
+}
+function getFixedBottom(placeholderRect, targetRect, offsetBottom) {
+	if (offsetBottom !== void 0 && Math.round(targetRect.bottom) < Math.round(placeholderRect.bottom) + offsetBottom) return offsetBottom + (window.innerHeight - targetRect.bottom);
+}
+
+//#endregion
+export { getFixedBottom, getFixedTop, getTargetRect };

package/dist/alert/Alert.d.ts

@@ -0,0 +1,59 @@
+import { SlotsDefineType, VueNode } from "../_util/type.js";
+import { SemanticClassNamesType, SemanticStylesType } 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 vue209 from "vue";
+import { SlotsType } from "vue";
+
+//#region src/alert/Alert.d.ts
+type AlertSemanticName = 'root' | 'icon' | 'section' | 'title' | 'description' | 'actions';
+type AlertClassNamesType = SemanticClassNamesType<AlertProps, AlertSemanticName>;
+type AlertStylesType = SemanticStylesType<AlertProps, AlertSemanticName>;
+interface AlertProps extends ComponentBaseProps {
+  /** Type of Alert styles, options:`success`, `info`, `warning`, `error` */
+  type?: 'success' | 'info' | 'warning' | 'error';
+  /** Whether Alert can be closed */
+  closable?: ClosableType;
+  /** Content of Alert */
+  title?: VueNode;
+  /**
+   * @deprecated please use `title` instead.
+   */
+  message?: VueNode;
+  /** Additional content of Alert */
+  description?: VueNode;
+  /** Trigger when animation ending of Alert */
+  afterClose?: () => void;
+  /** Whether to show icon */
+  showIcon?: boolean;
+  /** https://www.w3.org/TR/2014/REC-html5-20141028/dom.html#aria-role-attribute */
+  role?: string;
+  classes?: AlertClassNamesType;
+  styles?: AlertStylesType;
+  banner?: boolean;
+  icon?: VueNode;
+  closeIcon?: VueNode;
+  action?: VueNode;
+  id?: string;
+}
+type AlertSlots = SlotsDefineType<{
+  message?: () => any;
+  description?: () => any;
+  icon?: () => any;
+  closeIcon?: () => any;
+  action?: () => any;
+}>;
+interface AlertEmits {
+  /** Callback when close Alert */
+  close: (e: any) => any;
+  mouseenter: (e: any) => any;
+  mouseleave: (e: any) => any;
+  click: (e: any) => any;
+  [key: string]: (e: any) => any;
+}
+declare const Alert: vue209.DefineSetupFnComponent<AlertProps, AlertEmits, SlotsType<AlertSlots>, AlertProps & {
+  [x: `on${Capitalize<string>}`]: ((e: any) => any) | undefined;
+}, vue209.PublicProps>;
+//#endregion
+export { Alert, AlertEmits, AlertProps, AlertSlots };