antdv-next 0.0.111 → 1.0.0-alpha.2

package/dist/watermark/index.js

@@ -0,0 +1,269 @@
+import useToken from "../theme/useToken.js";
+import "../theme/internal.js";
+import { WatermarkContextProvider } from "./context.js";
+import toList_default from "../_util/toList.js";
+import useClips_default, { FontGap } from "./useClips.js";
+import useRafDebounce from "./useRafDebounce.js";
+import useSingletonCache from "./useSingletonCache.js";
+import { getPixelRatio, reRendering } from "./utils.js";
+import useWatermark from "./useWatermark.js";
+import { computed, createVNode, defineComponent, isVNode, mergeDefaults, mergeProps, ref, shallowRef, watch } from "vue";
+import { omit } from "es-toolkit";
+import { useMutateObserver } from "@v-c/mutate-observer";
+
+//#region src/watermark/index.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+/**
+* Only return `next` when size changed.
+* This is only used for elements compare, not a shallow equal!
+*/
+function getSizeDiff(prev, next) {
+	return prev.size === next.size ? prev : next;
+}
+const DEFAULT_GAP_X = 100;
+const DEFAULT_GAP_Y = 100;
+const fixedStyle = {
+	position: "relative",
+	overflow: "hidden"
+};
+const defaults = {
+	zIndex: 9,
+	rotate: -22,
+	inherit: true,
+	gap: [DEFAULT_GAP_X, DEFAULT_GAP_Y],
+	font: {}
+};
+const Watermark = /* @__PURE__ */ defineComponent((props, { slots, attrs }) => {
+	const [, token] = useToken();
+	const color = computed(() => props.font?.color ?? token.value.colorFill);
+	const fontSize = computed(() => props?.font?.fontSize ?? token.value?.fontSizeLG);
+	const fontWeight = computed(() => props?.font?.fontWeight ?? "normal");
+	const fontStyle = computed(() => props?.font?.fontStyle ?? "normal");
+	const fontFamily = computed(() => props?.font?.fontFamily ?? "sans-serif");
+	const textAlign = computed(() => props?.font?.textAlign ?? "center");
+	const gap = computed(() => props.gap);
+	const gapXCenter = computed(() => gap.value[0] / 2);
+	const gapYCenter = computed(() => gap.value[1] / 2);
+	const offsetLeft = computed(() => props.offset?.[0] ?? gapXCenter.value);
+	const offsetTop = computed(() => props.offset?.[1] ?? gapYCenter.value);
+	const mergedStyle = computed(() => {
+		return {
+			...fixedStyle,
+			...attrs.style
+		};
+	});
+	const markStyle = computed(() => {
+		const mergedMarkStyle = {
+			zIndex: props.zIndex,
+			position: "absolute",
+			left: 0,
+			top: 0,
+			width: "100%",
+			height: "100%",
+			pointerEvents: "none",
+			backgroundRepeat: "repeat"
+		};
+		/** Calculate the style of the offset */
+		let positionLeft = offsetLeft.value - gapXCenter.value;
+		let positionTop = offsetTop.value - gapYCenter.value;
+		if (positionLeft > 0) {
+			mergedMarkStyle.left = `${positionLeft}px`;
+			mergedMarkStyle.width = `calc(100% - ${positionLeft}px)`;
+			positionLeft = 0;
+		}
+		if (positionTop > 0) {
+			mergedMarkStyle.top = `${positionTop}px`;
+			mergedMarkStyle.height = `calc(100% - ${positionTop}px)`;
+			positionTop = 0;
+		}
+		mergedMarkStyle.backgroundPosition = `${positionLeft}px ${positionTop}px`;
+		return mergedMarkStyle;
+	});
+	const container = shallowRef(null);
+	const subElements = ref(/* @__PURE__ */ new Set());
+	const targetElements = computed(() => {
+		return [...container.value ? [container.value] : [], ...Array.from(subElements.value)];
+	});
+	/**
+	* Get the width and height of the watermark. The default values are as follows
+	* Image: [120, 64]; Content: It's calculated by content;
+	*/
+	const getMarkSize = (ctx) => {
+		let defaultWidth = 120;
+		let defaultHeight = 64;
+		if (!props.image && ctx.measureText) {
+			ctx.font = `${Number(fontSize.value)}px ${fontFamily.value}`;
+			const contents = toList_default(props.content);
+			const sizes = contents.map((item) => {
+				const metrics = ctx.measureText(item);
+				return [metrics.width, metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent];
+			});
+			defaultWidth = Math.ceil(Math.max(...sizes.map((size) => size[0])));
+			defaultHeight = Math.ceil(Math.max(...sizes.map((size) => size[1]))) * contents.length + (contents.length - 1) * FontGap;
+		}
+		const width = props.width;
+		const height = props.height;
+		return [width ?? defaultWidth, height ?? defaultHeight];
+	};
+	const getClips = useClips_default();
+	const getClipsCache = useSingletonCache();
+	const watermarkInfo = ref(null);
+	const renderWatermark = () => {
+		const ctx = document.createElement("canvas").getContext("2d");
+		if (ctx) {
+			const ratio = getPixelRatio();
+			const [markWidth, markHeight] = getMarkSize(ctx);
+			const drawCanvas = (drawContent) => {
+				const params = [
+					drawContent || "",
+					props.rotate,
+					ratio,
+					markWidth,
+					markHeight,
+					{
+						color: color.value,
+						fontSize: fontSize.value,
+						fontStyle: fontStyle.value,
+						fontWeight: fontWeight.value,
+						fontFamily: fontFamily.value,
+						textAlign: textAlign.value
+					},
+					gap.value[0],
+					gap.value[1]
+				];
+				const [nextClips, clipWidth] = getClipsCache(params, () => getClips(...params));
+				watermarkInfo.value = [nextClips, clipWidth];
+			};
+			if (props.image) {
+				const img = new Image();
+				img.onload = () => {
+					drawCanvas(img);
+				};
+				img.onerror = () => {
+					drawCanvas(props.content);
+				};
+				img.crossOrigin = "anonymous";
+				img.referrerPolicy = "no-referrer";
+				img.src = props.image;
+			} else drawCanvas(props.content);
+		}
+	};
+	const syncWatermark = useRafDebounce(renderWatermark);
+	const [appendWatermark, removeWatermark, isWatermarkEle] = useWatermark(markStyle);
+	watch([watermarkInfo, targetElements], ([watermarkInfo$1, targetElements$1]) => {
+		if (watermarkInfo$1) targetElements$1.forEach((holder) => {
+			appendWatermark(watermarkInfo$1[0], watermarkInfo$1[1], holder);
+		});
+	});
+	const onMutate = (mutations) => {
+		mutations.forEach((mutation) => {
+			if (reRendering(mutation, isWatermarkEle)) syncWatermark();
+			else if (mutation.target === container.value && mutation.attributeName === "style") {
+				const keyStyles = Object.keys(fixedStyle);
+				for (let i = 0; i < keyStyles.length; i += 1) {
+					const key = keyStyles[i];
+					const oriValue = mergedStyle.value[key];
+					const currentValue = container.value.style[key];
+					if (oriValue && oriValue !== currentValue) container.value.style[key] = oriValue;
+				}
+			}
+		});
+	};
+	useMutateObserver(targetElements, onMutate);
+	watch([
+		() => props.offset,
+		() => props.zIndex,
+		() => props.width,
+		() => props.height,
+		() => props.rotate,
+		() => props.image,
+		() => props.content,
+		fontSize,
+		fontWeight,
+		fontStyle,
+		fontFamily,
+		textAlign,
+		gap,
+		offsetLeft,
+		offsetTop
+	], syncWatermark, { immediate: true });
+	const watermarkContext = {
+		add: (ele) => {
+			const clone = new Set(subElements.value);
+			clone.add(ele);
+			subElements.value = getSizeDiff(subElements.value, clone);
+		},
+		remove: (ele) => {
+			removeWatermark(ele);
+			const clone = new Set(subElements.value);
+			clone.delete(ele);
+			subElements.value = getSizeDiff(subElements.value, clone);
+		}
+	};
+	return () => {
+		const children = slots?.default?.();
+		const childNode = props.inherit ? createVNode(WatermarkContextProvider, watermarkContext, _isSlot(children) ? children : { default: () => [children] }) : children;
+		return createVNode("div", mergeProps({
+			"ref": container,
+			"class": [props.rootClass, attrs.class]
+		}, omit(attrs, ["style", "class"]), { "style": mergedStyle.value }), [childNode]);
+	};
+}, {
+	props: /* @__PURE__ */ mergeDefaults({
+		zIndex: {
+			type: Number,
+			required: false
+		},
+		rotate: {
+			type: Number,
+			required: false
+		},
+		width: {
+			type: Number,
+			required: false
+		},
+		height: {
+			type: Number,
+			required: false
+		},
+		image: {
+			type: String,
+			required: false
+		},
+		content: {
+			type: [String, Array],
+			required: false
+		},
+		font: {
+			type: Object,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		gap: {
+			type: Array,
+			required: false
+		},
+		offset: {
+			type: Array,
+			required: false
+		},
+		inherit: {
+			type: Boolean,
+			required: false
+		}
+	}, defaults),
+	name: "AWatermark",
+	inheritAttrs: false
+});
+Watermark.install = (app) => {
+	app.component(Watermark.name, Watermark);
+};
+var watermark_default = Watermark;
+
+//#endregion
+export { watermark_default as default };

package/dist/watermark/useClips.js

@@ -0,0 +1,92 @@
+import toList_default from "../_util/toList.js";
+
+//#region src/watermark/useClips.ts
+const FontGap = 3;
+function prepareCanvas(width, height, ratio = 1) {
+	const canvas = document.createElement("canvas");
+	const ctx = canvas.getContext("2d");
+	const realWidth = width * ratio;
+	const realHeight = height * ratio;
+	canvas.setAttribute("width", `${realWidth}px`);
+	canvas.setAttribute("height", `${realHeight}px`);
+	ctx.save();
+	return [
+		ctx,
+		canvas,
+		realWidth,
+		realHeight
+	];
+}
+function getRotatePos(x, y, angle) {
+	return [x * Math.cos(angle) - y * Math.sin(angle), x * Math.sin(angle) + y * Math.cos(angle)];
+}
+/**
+* Get the clips of text content.
+* This is a lazy hook function since SSR no need this
+*/
+function useClips() {
+	const getClips = (content, rotate, ratio, width, height, font, gapX, gapY) => {
+		const [ctx, canvas, contentWidth, contentHeight] = prepareCanvas(width, height, ratio);
+		if (content instanceof HTMLImageElement) ctx.drawImage(content, 0, 0, contentWidth, contentHeight);
+		else {
+			const { color, fontSize, fontStyle, fontWeight, fontFamily, textAlign } = font;
+			const mergedFontSize = Number(fontSize) * ratio;
+			ctx.font = `${fontStyle} normal ${fontWeight} ${mergedFontSize}px/${height}px ${fontFamily}`;
+			ctx.fillStyle = color;
+			ctx.textAlign = textAlign;
+			ctx.textBaseline = "top";
+			toList_default(content)?.forEach((item, index) => {
+				ctx.fillText(item ?? "", contentWidth / 2, index * (mergedFontSize + FontGap * ratio));
+			});
+		}
+		const angle = Math.PI / 180 * Number(rotate);
+		const maxSize = Math.max(width, height);
+		const [rCtx, rCanvas, realMaxSize] = prepareCanvas(maxSize, maxSize, ratio);
+		rCtx.translate(realMaxSize / 2, realMaxSize / 2);
+		rCtx.rotate(angle);
+		if (contentWidth > 0 && contentHeight > 0) rCtx.drawImage(canvas, -contentWidth / 2, -contentHeight / 2);
+		let left = 0;
+		let right = 0;
+		let top = 0;
+		let bottom = 0;
+		const halfWidth = contentWidth / 2;
+		const halfHeight = contentHeight / 2;
+		[
+			[0 - halfWidth, 0 - halfHeight],
+			[0 + halfWidth, 0 - halfHeight],
+			[0 + halfWidth, 0 + halfHeight],
+			[0 - halfWidth, 0 + halfHeight]
+		].forEach(([x, y]) => {
+			const [targetX, targetY] = getRotatePos(x, y, angle);
+			left = Math.min(left, targetX);
+			right = Math.max(right, targetX);
+			top = Math.min(top, targetY);
+			bottom = Math.max(bottom, targetY);
+		});
+		const cutLeft = left + realMaxSize / 2;
+		const cutTop = top + realMaxSize / 2;
+		const cutWidth = right - left;
+		const cutHeight = bottom - top;
+		const realGapX = gapX * ratio;
+		const realGapY = gapY * ratio;
+		const filledWidth = (cutWidth + realGapX) * 2;
+		const filledHeight = cutHeight + realGapY;
+		const [fCtx, fCanvas] = prepareCanvas(filledWidth, filledHeight);
+		const drawImg = (targetX = 0, targetY = 0) => {
+			fCtx.drawImage(rCanvas, cutLeft, cutTop, cutWidth, cutHeight, targetX, targetY, cutWidth, cutHeight);
+		};
+		drawImg();
+		drawImg(cutWidth + realGapX, -cutHeight / 2 - realGapY / 2);
+		drawImg(cutWidth + realGapX, +cutHeight / 2 + realGapY / 2);
+		return [
+			fCanvas.toDataURL(),
+			filledWidth / ratio,
+			filledHeight / ratio
+		];
+	};
+	return getClips;
+}
+var useClips_default = useClips;
+
+//#endregion
+export { FontGap, useClips_default as default };

package/dist/watermark/useRafDebounce.js

@@ -0,0 +1,20 @@
+import { shallowRef } from "vue";
+import raf from "@v-c/util/dist/raf";
+
+//#region src/watermark/useRafDebounce.ts
+function useRafDebounce(callback) {
+	const executeRef = shallowRef(false);
+	const rafRef = shallowRef(null);
+	const wrapperCallback = callback;
+	return () => {
+		if (executeRef.value) return;
+		executeRef.value = true;
+		wrapperCallback();
+		rafRef.value = raf(() => {
+			executeRef.value = false;
+		});
+	};
+}
+
+//#endregion
+export { useRafDebounce as default };

package/dist/watermark/useSingletonCache.js

@@ -0,0 +1,22 @@
+import { ref } from "vue";
+import isEqual from "@v-c/util/dist/isEqual";
+
+//#region src/watermark/useSingletonCache.ts
+/**
+* Singleton cache will only take latest `cacheParams` as key
+* and return the result for callback matching.
+*/
+function useSingletonCache() {
+	const cacheRef = ref([null, null]);
+	const getCache = (cacheKeys, callback) => {
+		const filteredKeys = cacheKeys.map((item) => {
+			return item instanceof HTMLElement || Number.isNaN(item) ? "" : item;
+		});
+		if (!isEqual(cacheRef.value[0], filteredKeys)) cacheRef.value = [filteredKeys, callback()];
+		return cacheRef.value[1];
+	};
+	return getCache;
+}
+
+//#endregion
+export { useSingletonCache as default };

package/dist/watermark/useWatermark.js

@@ -0,0 +1,41 @@
+import { getStyleStr } from "./utils.js";
+import { reactive } from "vue";
+
+//#region src/watermark/useWatermark.ts
+const emphasizedStyle = { visibility: "visible !important" };
+function useWatermark(markStyle) {
+	const watermarkMap = reactive(/* @__PURE__ */ new Map());
+	const appendWatermark = (base64Url, markWidth, container) => {
+		if (container) {
+			if (!watermarkMap.get(container)) {
+				const newWatermarkEle = document.createElement("div");
+				watermarkMap.set(container, newWatermarkEle);
+			}
+			const watermarkEle = watermarkMap.get(container);
+			watermarkEle.setAttribute("style", getStyleStr({
+				...markStyle.value,
+				backgroundImage: `url('${base64Url}')`,
+				backgroundSize: `${Math.floor(markWidth)}px`,
+				...emphasizedStyle
+			}));
+			watermarkEle.removeAttribute("class");
+			watermarkEle.removeAttribute("hidden");
+			if (watermarkEle.parentElement !== container) container.append(watermarkEle);
+		}
+		return watermarkMap.get(container);
+	};
+	const removeWatermark = (container) => {
+		const watermarkEle = watermarkMap.get(container);
+		if (watermarkEle && container) container.removeChild(watermarkEle);
+		watermarkMap.delete(container);
+	};
+	const isWatermarkEle = (ele) => Array.from(watermarkMap.values()).includes(ele);
+	return [
+		appendWatermark,
+		removeWatermark,
+		isWatermarkEle
+	];
+}
+
+//#endregion
+export { useWatermark as default };

package/dist/watermark/utils.js

@@ -0,0 +1,22 @@
+//#region src/watermark/utils.ts
+/** converting camel-cased strings to be lowercase and link it with Separator */
+function toLowercaseSeparator(key) {
+	return key.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function getStyleStr(style) {
+	return Object.keys(style).map((key) => `${toLowercaseSeparator(key)}: ${style[key]};`).join(" ");
+}
+/** Returns the ratio of the device's physical pixel resolution to the css pixel resolution */
+function getPixelRatio() {
+	return window.devicePixelRatio || 1;
+}
+/** Whether to re-render the watermark */
+function reRendering(mutation, isWatermarkEle) {
+	let flag = false;
+	if (mutation.removedNodes.length) flag = Array.from(mutation.removedNodes).some((node) => isWatermarkEle(node));
+	if (mutation.type === "attributes" && isWatermarkEle(mutation.target)) flag = true;
+	return flag;
+}
+
+//#endregion
+export { getPixelRatio, getStyleStr, reRendering };

package/global.d.ts

@@ -0,0 +1,117 @@
+export {}
+
+declare module 'vue' {
+  export interface GlobalComponents {
+    AAffix: typeof import('antdv-next')['Affix']
+    AButton: typeof import('antdv-next')['Button']
+    AAlert: typeof import('antdv-next')['Alert']
+    AAnchor: typeof import('antdv-next')['Anchor']
+    ASpace: typeof import('antdv-next')['Space']
+    ADivider: typeof import('antdv-next')['Divider']
+    ASpaceCompact: typeof import('antdv-next')['SpaceCompact']
+    ASpaceAddon: typeof import('antdv-next')['SpaceAddon']
+    AFlex: typeof import('antdv-next')['Flex']
+    AConfigProvider: typeof import('antdv-next')['ConfigProvider']
+    ACol: typeof import('antdv-next')['Col']
+    ARow: typeof import('antdv-next')['Row']
+    ABadge: typeof import('antdv-next')['Badge']
+    ABadgeRibbon: typeof import('antdv-next')['Badge']['Ribbon']
+    ATag: typeof import('antdv-next')['Tag']
+    ACheckableTag: typeof import('antdv-next')['CheckableTag']
+    ALayout: typeof import('antdv-next')['Layout']
+    ALayoutHeader: typeof import('antdv-next')['LayoutHeader']
+    ALayoutFooter: typeof import('antdv-next')['LayoutFooter']
+    ALayoutContent: typeof import('antdv-next')['LayoutContent']
+    ALayoutSider: typeof import('antdv-next')['LayoutSider']
+    AEmpty: typeof import('antdv-next')['Empty']
+    AResult: typeof import('antdv-next')['Result']
+    ASpin: typeof import('antdv-next')['Spin']
+    ASkeleton: typeof import('antdv-next')['Skeleton']
+    ASkeletonButton: typeof import('antdv-next')['SkeletonButton']
+    ASkeletonAvatar: typeof import('antdv-next')['SkeletonAvatar']
+    ASkeletonInput: typeof import('antdv-next')['SkeletonInput']
+    ASkeletonImage: typeof import('antdv-next')['SkeletonImage']
+    ASkeletonNode: typeof import('antdv-next')['SkeletonNode']
+    AStatistic: typeof import('antdv-next')['Statistic']
+    AStatisticTimer: typeof import('antdv-next')['StatisticTimer']
+    ADescriptions: typeof import('antdv-next')['Descriptions']
+    ATimeline: typeof import('antdv-next')['Timeline']
+    AWatermark: typeof import('antdv-next')['Watermark']
+    AQrcode: typeof import('antdv-next')['QRCode']
+    ACollapse: typeof import('antdv-next')['Collapse']
+    ATooltip: typeof import('antdv-next')['Tooltip']
+    ASegmented: typeof import('antdv-next')['Segmented']
+    APopover: typeof import('antdv-next')['Popover']
+    APopconfirm: typeof import('antdv-next')['Popconfirm']
+    AFloatButton: typeof import('antdv-next')['FloatButton']
+    AFloatBackTop: typeof import('antdv-next')['BackTop']
+    AFloatButtonGroup: typeof import('antdv-next')['FloatButtonGroup']
+    AMenu: typeof import('antdv-next')['Menu']
+    ADropdown: typeof import('antdv-next')['Dropdown']
+    ATour: typeof import('antdv-next')['Tour']
+    ABreadcrumb: typeof import('antdv-next')['Breadcrumb']
+    AAvatar: typeof import('antdv-next')['Avatar']
+    AAvatarGroup: typeof import('antdv-next')['AvatarGroup']
+    AForm: typeof import('antdv-next')['Form']
+    AFormItem: typeof import('antdv-next')['FormItem']
+    ACheckbox: typeof import('antdv-next')['Checkbox']
+    ACheckboxGroup: typeof import('antdv-next')['CheckboxGroup']
+    ARadio: typeof import('antdv-next')['Radio']
+    ARadioGroup: typeof import('antdv-next')['RadioGroup']
+    ARadioButton: typeof import('antdv-next')['RadioButton']
+    ASwitch: typeof import('antdv-next')['Switch']
+    AColorPicker: typeof import('antdv-next')['ColorPicker']
+    ASlider: typeof import('antdv-next')['Slider']
+    AInput: typeof import('antdv-next')['Input']
+    AInputSearch: typeof import('antdv-next')['InputSearch']
+    AInputPassword: typeof import('antdv-next')['InputPassword']
+    AInputOtp: typeof import('antdv-next')['InputOTP']
+    AInputGroup: typeof import('antdv-next')['InputGroup']
+    AInputNumber: typeof import('antdv-next')['InputNumber']
+    ATextarea: typeof import('antdv-next')['TextArea']
+    ATypography: typeof import('antdv-next')['Typography']
+    ATypographyText: typeof import('antdv-next')['TypographyText']
+    ATypographyTitle: typeof import('antdv-next')['TypographyTitle']
+    ATypographyParagraph: typeof import('antdv-next')['TypographyParagraph']
+    ATypographyLink: typeof import('antdv-next')['TypographyLink']
+    ATabs: typeof import('antdv-next')['Tabs']
+    ATabPane: typeof import('antdv-next')['TabPane']
+    ASelect: typeof import('antdv-next')['Select']
+    ASelectOption: typeof import('antdv-next')['SelectOption']
+    ASelectOptGroup: typeof import('antdv-next')['SelectOptGroup']
+    ASplitter: typeof import('antdv-next')['Splitter']
+    ASplitterPanel: typeof import('antdv-next')['SplitterPanel']
+    ACard: typeof import('antdv-next')['Card']
+    ACardGrid: typeof import('antdv-next')['CardGrid']
+    ACardMeta: typeof import('antdv-next')['CardMeta']
+    AMasonry: typeof import('antdv-next')['Masonry']
+    ARate: typeof import('antdv-next')['Rate']
+    AProgress: typeof import('antdv-next')['Progress']
+    ADrawer: typeof import('antdv-next')['Drawer']
+    AModal: typeof import('antdv-next')['Modal']
+    ASteps: typeof import('antdv-next')['Steps']
+    AImage: typeof import('antdv-next')['Image']
+    AImagePreviewGroup: typeof import('antdv-next')['ImagePreviewGroup']
+    AApp: typeof import('antdv-next')['App']
+    ATree: typeof import('antdv-next')['Tree']
+    ADirectoryTree: typeof import('antdv-next')['DirectoryTree']
+    ATreeSelect: typeof import('antdv-next')['TreeSelect']
+    AUpload: typeof import('antdv-next')['Upload']
+    AUploadDragger: typeof import('antdv-next')['UploadDragger']
+    APagination: typeof import('antdv-next')['Pagination']
+    ATransfer: typeof import('antdv-next')['Transfer']
+    AMentions: typeof import('antdv-next')['Mentions']
+    ACarousel: typeof import('antdv-next')['Carousel']
+    ACascader: typeof import('antdv-next')['Cascader']
+    ATable: typeof import('antdv-next')['Table']
+    ATableColumn: typeof import('antdv-next')['TableColumn']
+    ATableSummary: typeof import('antdv-next')['TableSummary']
+    ATableSummaryRow: typeof import('antdv-next')['TableSummaryRow']
+    ATableSummaryCell: typeof import('antdv-next')['TableSummaryCell']
+    ACalendar: typeof import('antdv-next')['Calendar']
+    ADatePicker: typeof import('antdv-next')['DatePicker']
+    ARangePicker: typeof import('antdv-next')['DateRangePicker']
+    ATimePicker: typeof import('antdv-next')['TimePicker']
+    ATimeRangePicker: typeof import('antdv-next')['TimeRangePicker']
+  }
+}