antdv-next 0.0.111 → 1.0.0-alpha.2

package/dist/button/Button.d.ts

@@ -0,0 +1,62 @@
+import { SizeType } from "../config-provider/SizeContext.js";
+import { RenderNodeFn, VueNode } from "../_util/type.js";
+import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { ButtonColorType, ButtonHTMLType, ButtonShape, ButtonType, ButtonVariantType } from "./buttonHelper.js";
+import { ComponentBaseProps } from "../config-provider/context.js";
+import * as vue237 from "vue";
+import { SlotsType } from "vue";
+
+//#region src/button/Button.d.ts
+type LegacyButtonType = ButtonType | 'danger';
+type ButtonSemanticName = 'root' | 'icon' | 'content';
+type ButtonClassNamesType = SemanticClassNamesType<BaseButtonProps, ButtonSemanticName>;
+type ButtonStylesType = SemanticStylesType<BaseButtonProps, ButtonSemanticName>;
+interface BaseButtonProps extends ComponentBaseProps {
+  type?: ButtonType;
+  color?: ButtonColorType;
+  variant?: ButtonVariantType;
+  icon?: VueNode;
+  iconPlacement?: 'start' | 'end';
+  shape?: ButtonShape;
+  size?: SizeType;
+  disabled?: boolean;
+  loading?: boolean | {
+    delay?: number;
+    icon?: RenderNodeFn;
+  };
+  ghost?: boolean;
+  danger?: boolean;
+  block?: boolean;
+  [key: `data-${string}`]: string;
+  classes?: ButtonClassNamesType;
+  styles?: ButtonStylesType;
+  autoFocus?: boolean;
+  /** @private Only for internal usage. Do not use in your production */
+  _skipSemantic?: boolean;
+}
+interface ButtonProps extends BaseButtonProps {
+  href?: string;
+  htmlType?: ButtonHTMLType;
+  target?: '_self' | '_blank' | '_parent' | '_top' | string;
+  autoInsertSpace?: boolean;
+}
+interface ButtonEmits {
+  click: (e: MouseEvent) => void;
+  [key: string]: (...args: any[]) => any;
+}
+interface ButtonSlots {
+  default?: () => any;
+  icon?: () => any;
+  loadingIcon?: () => any;
+}
+declare const InternalCompoundedButton: vue237.DefineSetupFnComponent<ButtonProps, ButtonEmits, SlotsType<ButtonSlots>, ButtonProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue237.PublicProps>;
+type CompoundedComponent = typeof InternalCompoundedButton & {
+  /** @internal */
+  __ANT_BUTTON: boolean;
+};
+declare const Button: CompoundedComponent;
+//#endregion
+export { Button, ButtonProps, ButtonSemanticName, LegacyButtonType };

package/dist/button/Button.js

@@ -0,0 +1,344 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import { useMergeSemantic, useToArr, useToProps } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { getSlotPropsFnRun, toPropsRefs } from "../_util/tools.js";
+import { useSize } from "../config-provider/hooks/useSize.js";
+import { useCompactItemContext } from "../space/Compact.js";
+import { useDisabledContext } from "../config-provider/DisabledContext.js";
+import wave_default from "../_util/wave/index.js";
+import { isTwoCNChar, isUnBorderedButtonVariant, spaceChildren } from "./buttonHelper.js";
+import IconWrapper_default from "./IconWrapper.js";
+import DefaultLoadingIcon_default from "./DefaultLoadingIcon.js";
+import style_default from "./style/index.js";
+import compact_default from "./style/compact.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 { omit } from "es-toolkit";
+import { toArray } from "es-toolkit/compat";
+
+//#region src/button/Button.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+function convertLegacyProps(type) {
+	if (type === "danger") return { danger: true };
+	if (type) return { type };
+	return {};
+}
+function getLoadingConfig(loading) {
+	if (typeof loading === "object" && loading) {
+		let delay = loading?.delay;
+		delay = !Number.isNaN(delay) && typeof delay === "number" ? delay : 0;
+		return {
+			loading: delay <= 0,
+			delay
+		};
+	}
+	return {
+		loading: !!loading,
+		delay: 0
+	};
+}
+const ButtonTypeMap = {
+	default: ["default", "outlined"],
+	primary: ["primary", "solid"],
+	dashed: ["default", "dashed"],
+	link: ["link", "link"],
+	text: ["default", "text"]
+};
+const InternalCompoundedButton = /* @__PURE__ */ defineComponent((props, { slots, attrs, emit }) => {
+	const mergedType = computed(() => props.type || "default");
+	const { prefixCls, direction, class: contextClassName, style: contextStyle, classes: contextClassNames, styles: contextStyles,...button } = useComponentBaseConfig("button", props, [
+		"autoInsertSpace",
+		"variant",
+		"shape",
+		"color"
+	], "btn");
+	const { classes, styles } = toPropsRefs(props, "classes", "styles");
+	const shape = computed(() => props.shape || button?.shape.value || "default");
+	const mergedColorVariant = computed(() => {
+		const { color, variant, type, danger } = props;
+		if (color && variant) return [color, variant];
+		if (type || danger) {
+			const colorVariantPair = ButtonTypeMap[mergedType.value] || [];
+			if (danger) return ["danger", colorVariantPair[1]];
+			return colorVariantPair;
+		}
+		if (button?.color?.value && button?.variant?.value) return [button.color.value, button.variant.value];
+		return ["default", "outlined"];
+	});
+	const mergedColor = computed(() => mergedColorVariant.value[0]);
+	const mergedVariant = computed(() => mergedColorVariant.value[1]);
+	const isDanger = computed(() => mergedColor.value === "danger");
+	const mergedColorText = computed(() => isDanger.value ? "dangerous" : mergedColor.value);
+	const mergedInsertSpace = computed(() => {
+		return props?.autoInsertSpace ?? button.autoInsertSpace?.value ?? true;
+	});
+	const [hashId, cssVarCls] = style_default(prefixCls);
+	const disabled = useDisabledContext();
+	const mergedDisabled = computed(() => {
+		return props?.disabled ?? disabled.value;
+	});
+	const loadingOrDelay = computed(() => {
+		return getLoadingConfig(props.loading);
+	});
+	const innerLoading = shallowRef(loadingOrDelay.value.loading);
+	const hasTwoCNChar = shallowRef(false);
+	const buttonRef = shallowRef();
+	const isMountRef = shallowRef(true);
+	onMounted(() => {
+		isMountRef.value = false;
+		if (props.autoFocus && buttonRef.value) buttonRef.value?.focus?.();
+	});
+	onBeforeUnmount(() => {
+		isMountRef.value = true;
+	});
+	let delayTimer = null;
+	watch([() => loadingOrDelay.value.delay, () => loadingOrDelay.value.loading], async (_new, _old, onCleanup) => {
+		if (loadingOrDelay.value.delay > 0) delayTimer = setTimeout(() => {
+			delayTimer = null;
+			innerLoading.value = true;
+		}, loadingOrDelay.value.delay);
+		else innerLoading.value = loadingOrDelay.value.loading;
+		onCleanup(() => {
+			if (delayTimer) {
+				clearTimeout(delayTimer);
+				delayTimer = null;
+			}
+		});
+	}, { immediate: true });
+	watch([
+		mergedInsertSpace,
+		buttonRef,
+		mergedVariant
+	], async () => {
+		await nextTick();
+		if (!buttonRef.value || !mergedInsertSpace.value) return;
+		const buttonText = buttonRef.value.textContent || "";
+		const children = filterEmpty(slots?.default?.());
+		const iconChildren = toArray(getSlotPropsFnRun(slots, props, "icon"));
+		if (children.length === 1 && iconChildren.length === 0 && !isUnBorderedButtonVariant(mergedVariant.value) && isTwoCNChar(buttonText.trim())) {
+			if (!hasTwoCNChar.value) hasTwoCNChar.value = true;
+		} else if (hasTwoCNChar.value) hasTwoCNChar.value = false;
+	}, { immediate: true });
+	const handleClick = (e) => {
+		if (innerLoading.value || mergedDisabled.value) {
+			e.preventDefault();
+			return;
+		}
+		emit("click", e);
+	};
+	const { compactSize, compactItemClassnames } = useCompactItemContext(prefixCls, direction);
+	const sizeClassNameMap = {
+		large: "lg",
+		small: "sm",
+		middle: void 0
+	};
+	const sizeFullName = useSize((ctxSize) => props?.size ?? compactSize.value ?? ctxSize);
+	const mergedIconPlacement = computed(() => props?.iconPlacement ?? "start");
+	const mergedProps = computed(() => {
+		return {
+			...props,
+			type: mergedType.value,
+			color: mergedColor.value,
+			danger: isDanger.value,
+			shape: shape.value,
+			size: sizeFullName.value,
+			disabled: mergedDisabled.value,
+			loading: innerLoading.value,
+			iconPlacement: mergedIconPlacement.value
+		};
+	});
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(...props._skipSemantic ? [] : [contextClassNames, classes]), useToArr(...props._skipSemantic ? [] : [contextStyles, styles]), useToProps(mergedProps));
+	return () => {
+		const { loading } = props;
+		const sizeCls = sizeFullName.value ? sizeClassNameMap?.[sizeFullName.value] ?? "" : "";
+		const iconChildren = getSlotPropsFnRun(slots, props, "icon");
+		const hasIcon = !!iconChildren;
+		const iconType = innerLoading.value ? "loading" : hasIcon;
+		const children = filterEmpty(slots?.default?.());
+		const needInserted = children.length === 1 && !hasIcon && !isUnBorderedButtonVariant(mergedVariant.value);
+		const kids = children.length ? spaceChildren(children, needInserted && mergedInsertSpace.value, mergedStyles.value.content, mergedClassNames.value.content) : null;
+		const cls = classNames(prefixCls.value, hashId.value, cssVarCls.value, {
+			[`${prefixCls.value}-${shape.value}`]: shape.value !== "default" && shape.value,
+			[`${prefixCls.value}-${mergedType.value}`]: mergedType.value,
+			[`${prefixCls.value}-dangerous`]: props.danger,
+			[`${prefixCls.value}-color-${mergedColorText.value}`]: mergedColorText.value,
+			[`${prefixCls.value}-variant-${mergedVariant.value}`]: mergedVariant.value,
+			[`${prefixCls.value}-${sizeCls}`]: sizeCls,
+			[`${prefixCls.value}-icon-only`]: !children.length && !!iconType,
+			[`${prefixCls.value}-background-ghost`]: props.ghost && !isUnBorderedButtonVariant(mergedVariant.value),
+			[`${prefixCls.value}-loading`]: innerLoading.value,
+			[`${prefixCls.value}-two-chinese-chars`]: hasTwoCNChar.value && mergedInsertSpace.value && !innerLoading.value,
+			[`${prefixCls.value}-block`]: props.block,
+			[`${prefixCls.value}-rtl`]: direction.value === "rtl",
+			[`${prefixCls.value}-icon-end`]: mergedIconPlacement.value === "end"
+		}, compactItemClassnames.value, attrs.class, props.rootClass, contextClassName.value, mergedClassNames.value.root);
+		const fullStyle = [
+			mergedStyles.value.root,
+			contextStyle.value,
+			attrs.style
+		];
+		let loadingIconNode = null;
+		const iconNodes = filterEmpty(slots?.loadingIcon?.());
+		if (iconNodes.length) loadingIconNode = innerLoading.value && iconNodes;
+		else loadingIconNode = innerLoading.value && typeof loading === "object" && loading.icon ? typeof loading.icon === "function" ? loading.icon() : loading.icon : null;
+		const iconSharedProps = {
+			class: mergedClassNames.value.icon,
+			style: mergedStyles.value.icon
+		};
+		const iconNode = hasIcon && !innerLoading.value ? createVNode(IconWrapper_default, mergeProps({ "prefixCls": prefixCls.value }, iconSharedProps), _isSlot(iconChildren) ? iconChildren : { default: () => [iconChildren] }) : loadingIconNode ? createVNode(IconWrapper_default, mergeProps({ "prefixCls": prefixCls.value }, iconSharedProps), _isSlot(loadingIconNode) ? loadingIconNode : { default: () => [loadingIconNode] }) : createVNode(DefaultLoadingIcon_default, mergeProps({
+			"existIcon": hasIcon,
+			"prefixCls": prefixCls.value,
+			"loading": innerLoading.value,
+			"mount": isMountRef.value
+		}, iconSharedProps), null);
+		const mergedHref = props.href;
+		const htmlType = props.htmlType ?? "button";
+		if (mergedHref !== void 0) return createVNode("a", mergeProps(omit(attrs, ["class", "style"]), {
+			"ref": buttonRef,
+			"class": [cls, { [`${prefixCls.value}-disabled`]: mergedDisabled.value }],
+			"style": fullStyle,
+			"href": mergedDisabled.value ? void 0 : mergedHref,
+			"onClick": handleClick,
+			"target": props.target,
+			"aria-disabled": mergedDisabled.value
+		}), [iconNode, kids]);
+		let buttonNodes = createVNode("button", mergeProps(omit(attrs, ["class", "style"]), {
+			"ref": buttonRef,
+			"type": htmlType,
+			"class": cls,
+			"style": fullStyle,
+			"onClick": handleClick,
+			"disabled": mergedDisabled.value
+		}), [
+			iconNode,
+			kids,
+			compactItemClassnames.value ? createVNode(compact_default, { "prefixCls": prefixCls.value }, null) : null
+		]);
+		if (!isUnBorderedButtonVariant(mergedVariant.value)) {
+			const _buttonNodes = function() {
+				return buttonNodes;
+			}();
+			buttonNodes = createVNode(wave_default, {
+				"component": "Button",
+				"disabled": innerLoading.value
+			}, _isSlot(buttonNodes) ? buttonNodes : { default: () => [_buttonNodes] });
+		}
+		return buttonNodes;
+	};
+}, {
+	emits: ["click"],
+	props: /* @__PURE__ */ mergeDefaults({
+		href: {
+			type: String,
+			required: false
+		},
+		htmlType: {
+			type: String,
+			required: false
+		},
+		target: {
+			type: String,
+			required: false
+		},
+		autoInsertSpace: {
+			type: Boolean,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		color: { required: false },
+		variant: {
+			type: String,
+			required: false
+		},
+		icon: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		iconPlacement: {
+			type: String,
+			required: false
+		},
+		shape: {
+			type: String,
+			required: false
+		},
+		size: {
+			type: [String, null],
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		loading: {
+			type: [Boolean, Object],
+			required: false
+		},
+		ghost: {
+			type: Boolean,
+			required: false
+		},
+		danger: {
+			type: Boolean,
+			required: false
+		},
+		block: {
+			type: Boolean,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		autoFocus: {
+			type: Boolean,
+			required: false
+		},
+		_skipSemantic: {
+			type: Boolean,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	}, {
+		iconPlacement: "start",
+		htmlType: "button",
+		autoInsertSpace: void 0,
+		disabled: void 0,
+		size: void 0
+	}),
+	name: "AButton",
+	inheritAttrs: false
+});
+const Button = InternalCompoundedButton;
+Button.__ANT_BUTTON = true;
+Button.install = (app) => {
+	app.component(InternalCompoundedButton.name, Button);
+};
+var Button_default = Button;
+
+//#endregion
+export { convertLegacyProps, Button_default as default };

package/dist/button/DefaultLoadingIcon.js

@@ -0,0 +1,91 @@
+import IconWrapper_default from "./IconWrapper.js";
+import { Transition, createVNode, defineComponent, mergeProps } from "vue";
+import { classNames } from "@v-c/util";
+import { LoadingOutlined } from "@antdv-next/icons";
+
+//#region src/button/DefaultLoadingIcon.tsx
+const InnerLoadingIcon = /* @__PURE__ */ defineComponent((props) => {
+	return () => {
+		const { prefixCls, iconClassName } = props;
+		const mergedIconCls = classNames(`${prefixCls}-loading-icon`);
+		return createVNode(IconWrapper_default, {
+			"prefixCls": prefixCls,
+			"class": mergedIconCls
+		}, { default: () => [createVNode(LoadingOutlined, { "class": iconClassName }, null)] });
+	};
+}, {
+	props: {
+		prefixCls: {
+			type: String,
+			required: true
+		},
+		iconClassName: {
+			type: String,
+			required: false
+		}
+	},
+	name: "InnerLoadingIcon"
+});
+const DefaultLoadingIcon = /* @__PURE__ */ defineComponent((props, { attrs }) => {
+	function onBeforeEnter(el) {
+		const element = el;
+		element.style.width = "0px";
+		element.style.opacity = "0";
+		element.style.transform = "scale(0)";
+	}
+	function onEnter(el, done) {
+		const element = el;
+		element.style.width = `${element.scrollWidth}px`;
+		element.style.opacity = "1";
+		element.style.transform = "scale(1)";
+		done();
+	}
+	function onBeforeLeave(el) {
+		const element = el;
+		element.style.width = `${element.scrollWidth}px`;
+		element.style.opacity = "1";
+		element.style.transform = "scale(1)";
+	}
+	function onLeave(el, done) {
+		const element = el;
+		element.offsetHeight;
+		element.style.width = "0px";
+		element.style.opacity = "0";
+		element.style.transform = "scale(0)";
+		done();
+	}
+	return () => {
+		const { prefixCls, loading, existIcon, mount } = props;
+		const visible = !!loading;
+		if (existIcon) return createVNode(InnerLoadingIcon, mergeProps({ "prefixCls": prefixCls }, attrs), null);
+		return createVNode(Transition, {
+			"name": `${prefixCls}-loading-icon-motion`,
+			"appear": !mount,
+			"onBeforeEnter": onBeforeEnter,
+			"onEnter": onEnter,
+			"onBeforeLeave": onBeforeLeave,
+			"onLeave": onLeave
+		}, { default: () => [visible ? createVNode(InnerLoadingIcon, mergeProps({ "prefixCls": prefixCls }, attrs), null) : null] });
+	};
+}, { props: {
+	prefixCls: {
+		type: String,
+		required: true
+	},
+	existIcon: {
+		type: Boolean,
+		required: true
+	},
+	loading: {
+		type: [Boolean, Object],
+		required: false
+	},
+	mount: {
+		type: Boolean,
+		required: true
+	}
+} });
+var DefaultLoadingIcon_default = DefaultLoadingIcon;
+
+//#endregion
+export { DefaultLoadingIcon_default as default };

package/dist/button/IconWrapper.js

@@ -0,0 +1,20 @@
+import { createVNode, defineComponent } from "vue";
+
+//#region src/button/IconWrapper.tsx
+const IconWrapper = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	return () => {
+		const { prefixCls } = props;
+		const iconWrapperCls = `${prefixCls}-icon`;
+		return createVNode("span", { "class": [iconWrapperCls] }, [slots?.default?.()]);
+	};
+}, {
+	props: { prefixCls: {
+		type: String,
+		required: true
+	} },
+	name: "IconWrapper"
+});
+var IconWrapper_default = IconWrapper;
+
+//#endregion
+export { IconWrapper_default as default };

package/dist/button/buttonHelper.d.ts

@@ -0,0 +1,16 @@
+import { CSSProperties, VNodeChild } from "vue";
+
+//#region src/button/buttonHelper.d.ts
+
+declare const _ButtonTypes: readonly ["default", "primary", "dashed", "link", "text"];
+type ButtonType = (typeof _ButtonTypes)[number];
+declare const _ButtonShapes: readonly ["default", "circle", "round", "square"];
+type ButtonShape = (typeof _ButtonShapes)[number];
+declare const _ButtonHTMLTypes: readonly ["submit", "button", "reset"];
+type ButtonHTMLType = (typeof _ButtonHTMLTypes)[number];
+declare const _ButtonVariantTypes: readonly ["outlined", "dashed", "solid", "filled", "text", "link"];
+type ButtonVariantType = (typeof _ButtonVariantTypes)[number];
+declare const _ButtonColorTypes: readonly ["default", "primary", "danger", "blue", "purple", "cyan", "green", "magenta", "pink", "red", "orange", "yellow", "volcano", "geekblue", "lime", "gold"];
+type ButtonColorType = (typeof _ButtonColorTypes)[number];
+//#endregion
+export { ButtonColorType, ButtonHTMLType, ButtonShape, ButtonType, ButtonVariantType, _ButtonColorTypes, _ButtonVariantTypes };

package/dist/button/buttonHelper.js

@@ -0,0 +1,79 @@
+import { PresetColors } from "../theme/interface/presetColors.js";
+import { Fragment, Text, cloneVNode, createVNode, isVNode } from "vue";
+
+//#region src/button/buttonHelper.tsx
+const rxTwoCNChar = /^[\u4E00-\u9FA5]{2}$/;
+const isTwoCNChar = rxTwoCNChar.test.bind(rxTwoCNChar);
+function isUnBorderedButtonVariant(type) {
+	return type === "text" || type === "link";
+}
+function splitCNCharsBySpace(child, needInserted, style, className) {
+	if (child === null || child === void 0) return child;
+	const SPACE = needInserted ? " " : "";
+	if (typeof child === "string" || typeof child === "number") {
+		const text = String(child);
+		const content = isTwoCNChar(text) ? text.split("").join(SPACE) : text;
+		return createVNode("span", {
+			class: className,
+			style
+		}, content);
+	}
+	if (isVNode(child)) {
+		if (child.type === Text) {
+			const text = String(child.children ?? "");
+			const content = isTwoCNChar(text) ? text.split("").join(SPACE) : text;
+			return createVNode("span", {
+				key: child.key,
+				class: className,
+				style
+			}, content);
+		}
+		if (child.type === Fragment) return createVNode("span", {
+			key: child.key,
+			class: className,
+			style
+		}, child.children);
+		if (typeof child.type === "string" && typeof child.children === "string" && isTwoCNChar(child.children)) return cloneVNode(child, {
+			class: className,
+			style
+		}, child.children?.split("")?.join?.(SPACE));
+		return child;
+	}
+	return child;
+}
+function isPureTextChild(child) {
+	if (typeof child === "string" || typeof child === "number") return true;
+	if (isVNode(child)) return child.type === Text && typeof child.children === "string";
+	return false;
+}
+function getChildText(child) {
+	if (typeof child === "string" || typeof child === "number") return String(child);
+	if (isVNode(child) && child.type === Text && typeof child.children === "string") return child.children;
+	return "";
+}
+function spaceChildren(children, needInserted, style, className) {
+	const childList = [];
+	let isPrevChildPure = false;
+	children.forEach((child) => {
+		const isCurrentChildPure = isPureTextChild(child);
+		if (isPrevChildPure && isCurrentChildPure) {
+			const lastIndex = childList.length - 1;
+			const lastChild = childList[lastIndex];
+			const lastText = getChildText(lastChild);
+			const currentText = getChildText(child);
+			if (lastText !== "" && currentText !== "") childList[lastIndex] = `${lastText}${currentText}`;
+			else childList.push(child);
+		} else childList.push(child);
+		isPrevChildPure = isCurrentChildPure;
+	});
+	return childList.map((item) => splitCNCharsBySpace(item, needInserted, style, className));
+}
+const _ButtonColorTypes = [
+	"default",
+	"primary",
+	"danger",
+	...PresetColors
+];
+
+//#endregion
+export { isTwoCNChar, isUnBorderedButtonVariant, spaceChildren };

package/dist/button/index.d.ts

@@ -0,0 +1,3 @@
+import { SizeType } from "../config-provider/SizeContext.js";
+import { ButtonColorType, ButtonHTMLType, ButtonShape, ButtonType, ButtonVariantType, _ButtonColorTypes, _ButtonVariantTypes } from "./buttonHelper.js";
+import { Button, ButtonProps, ButtonSemanticName, LegacyButtonType } from "./Button.js";

package/dist/button/index.js

@@ -0,0 +1,8 @@
+import { isTwoCNChar, isUnBorderedButtonVariant, spaceChildren } from "./buttonHelper.js";
+import Button_default, { convertLegacyProps } from "./Button.js";
+
+//#region src/button/index.ts
+var button_default = Button_default;
+
+//#endregion
+export { button_default as default };

package/dist/button/style/compact.js

@@ -0,0 +1,42 @@
+import { genSubStyleComponent } from "../../theme/util/genStyleUtils.js";
+import "../../theme/internal.js";
+import { prepareComponentToken, prepareToken } from "./token.js";
+import { genCompactItemStyle } from "../../style/compact-item.js";
+import { genCompactItemVerticalStyle } from "../../style/compact-item-vertical.js";
+
+//#region src/button/style/compact.ts
+const genButtonCompactStyle = (token) => {
+	const { componentCls, colorPrimaryHover, lineWidth, calc } = token;
+	const insetOffset = calc(lineWidth).mul(-1).equal();
+	const getCompactBorderStyle = (vertical) => {
+		const itemCls = `${componentCls}-compact${vertical ? "-vertical" : ""}-item`;
+		const selector = `${itemCls}${componentCls}-primary:not([disabled])`;
+		return {
+			[itemCls]: { transition: `none` },
+			[`${selector} + ${selector}::before`]: {
+				position: "absolute",
+				top: vertical ? insetOffset : 0,
+				insetInlineStart: vertical ? 0 : insetOffset,
+				backgroundColor: colorPrimaryHover,
+				content: "\"\"",
+				width: vertical ? "100%" : lineWidth,
+				height: vertical ? lineWidth : "100%"
+			}
+		};
+	};
+	return {
+		...getCompactBorderStyle(),
+		...getCompactBorderStyle(true)
+	};
+};
+var compact_default = genSubStyleComponent(["Button", "compact"], (token) => {
+	const buttonToken = prepareToken(token);
+	return [
+		genCompactItemStyle(buttonToken),
+		genCompactItemVerticalStyle(buttonToken),
+		genButtonCompactStyle(buttonToken)
+	];
+}, prepareComponentToken);
+
+//#endregion
+export { compact_default as default };