antdv-next 0.0.111 → 1.0.0-alpha.2

package/dist/radio/radio.js

@@ -0,0 +1,200 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import { getAttrStyleAndClass as getAttrStyleAndClass$1, useMergeSemantic, useToArr, useToProps } from "../_util/hooks/useMergeSemantic.js";
+import { devUseWarning, isDev } from "../_util/warning.js";
+import "../_util/hooks/index.js";
+import { toPropsRefs } from "../_util/tools.js";
+import { checkRenderNode } from "../_util/vueNode.js";
+import useCSSVarCls_default from "../config-provider/hooks/useCSSVarCls.js";
+import { useDisabledContext } from "../config-provider/DisabledContext.js";
+import { TARGET_CLS } from "../_util/wave/interface.js";
+import wave_default from "../_util/wave/index.js";
+import { useFormItemInputContext } from "../form/context.js";
+import { useRadioGroupContext, useRadioOptionTypeContext } from "./context.js";
+import useBubbleLock from "../checkbox/useBubbleLock.js";
+import style_default from "./style/index.js";
+import { computed, createVNode, defineComponent, mergeProps, shallowRef } from "vue";
+import { clsx } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import { omit } from "es-toolkit";
+import VcCheckbox from "@v-c/checkbox";
+
+//#region src/radio/radio.tsx
+const InternalRadio = /* @__PURE__ */ defineComponent((props, { slots, expose, attrs, emit }) => {
+	const groupContext = useRadioGroupContext();
+	const radioOptionTypeContext = useRadioOptionTypeContext();
+	const { prefixCls: radioPrefixCls, direction, class: contextClassName, style: contextStyle, classes: contextClassNames, styles: contextStyles } = useComponentBaseConfig("radio", props);
+	const innerRef = shallowRef();
+	const formItemInputContext = useFormItemInputContext();
+	if (isDev) devUseWarning("Radio")(!props.optionType, "usage", "`optionType` is only support in RadioGroup.");
+	const onChange = (e) => {
+		emit("change", e);
+		groupContext?.value?.onChange?.(e);
+	};
+	const { classes, styles } = toPropsRefs(props, "classes", "styles");
+	const isButtonType = computed(() => (groupContext?.value?.optionType || radioOptionTypeContext?.value) === "button");
+	const prefixCls = computed(() => isButtonType.value ? `${radioPrefixCls.value}-button` : radioPrefixCls.value);
+	const rootCls = useCSSVarCls_default(radioPrefixCls);
+	const [hashId, cssVarCls] = style_default(radioPrefixCls, rootCls);
+	const disabled = useDisabledContext();
+	const radioProps = computed(() => {
+		const _radioProps = { ...omit(props, [
+			"prefixCls",
+			"classes",
+			"styles",
+			"title",
+			"rootClass"
+		]) };
+		_radioProps.onChange = onChange;
+		if (groupContext?.value) {
+			_radioProps.name = groupContext.value.name;
+			_radioProps.checked = props.value === groupContext.value.value;
+			_radioProps.disabled = _radioProps.disabled ?? _radioProps.disabled;
+		}
+		_radioProps.disabled = _radioProps.disabled ?? disabled.value;
+		return _radioProps;
+	});
+	const mergedProps = computed(() => {
+		return {
+			...props,
+			...radioProps.value
+		};
+	});
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(contextClassNames, classes), useToArr(contextStyles, styles), useToProps(mergedProps));
+	const [onLabelClick, onInputClick] = useBubbleLock((e) => {
+		emit("click", e);
+	});
+	expose({
+		blur: () => innerRef.value?.blur?.(),
+		focus: () => innerRef.value?.focus?.(),
+		input: computed(() => innerRef.value?.input)
+	});
+	return () => {
+		const { rootClass, title } = props;
+		const { className, style, restAttrs } = getAttrStyleAndClass$1(attrs);
+		const wrapperClassString = clsx(`${prefixCls.value}-wrapper`, {
+			[`${prefixCls.value}-wrapper-checked`]: radioProps.value.checked,
+			[`${prefixCls.value}-wrapper-disabled`]: radioProps.value.disabled,
+			[`${prefixCls.value}-wrapper-rtl`]: direction.value === "rtl",
+			[`${prefixCls.value}-wrapper-in-form-item`]: formItemInputContext?.value?.isFormItemInput,
+			[`${prefixCls.value}-wrapper-block`]: !!groupContext?.value?.block
+		}, contextClassName.value, className, rootClass, mergedClassNames.value.root, hashId.value, cssVarCls.value, rootCls.value);
+		const children = checkRenderNode(filterEmpty(slots?.default?.() ?? []));
+		return createVNode(wave_default, {
+			"component": "Radio",
+			"disabled": radioProps.value.disabled
+		}, { default: () => [createVNode("label", mergeProps(restAttrs, {
+			"class": wrapperClassString,
+			"style": {
+				...mergedStyles.value.root,
+				...contextStyle.value,
+				...style
+			},
+			"onMouseenter": (e) => {
+				emit("mouseenter", e);
+			},
+			"onMouseleave": (e) => {
+				emit("mouseleave", e);
+			},
+			"title": title,
+			"onClick": onLabelClick
+		}), [createVNode(VcCheckbox, mergeProps(radioProps.value, {
+			"class": clsx(mergedClassNames.value.icon, { [TARGET_CLS]: !isButtonType.value }),
+			"style": mergedStyles.value.icon,
+			"type": "radio",
+			"prefixCls": prefixCls.value,
+			"ref": innerRef,
+			"onClick": onInputClick
+		}, { "onUpdate:checked": (checked) => {
+			emit("update:checked", checked);
+		} }), null), children ? createVNode("span", {
+			"class": clsx(`${prefixCls.value}-label`, mergedClassNames.value.label),
+			"style": mergedStyles.value.label
+		}, [children]) : null])] });
+	};
+}, {
+	emits: [
+		"change",
+		"update:checked",
+		"update:value",
+		"mouseenter",
+		"mouseleave",
+		"keypress",
+		"keydown",
+		"focus",
+		"blur",
+		"click"
+	],
+	props: {
+		optionType: {
+			type: String,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		defaultChecked: {
+			type: Boolean,
+			required: false
+		},
+		checked: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		title: {
+			type: String,
+			required: false
+		},
+		value: { required: false },
+		tabIndex: {
+			type: Number,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		id: {
+			type: String,
+			required: false
+		},
+		autoFocus: {
+			type: Boolean,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		skipGroup: {
+			type: Boolean,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	},
+	name: "ARadio",
+	inheritAttrs: false
+});
+var radio_default = InternalRadio;
+
+//#endregion
+export { radio_default as default };

package/dist/radio/radioButton.js

@@ -0,0 +1,87 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import { useRadioOptionTypeContextProvider } from "./context.js";
+import radio_default from "./radio.js";
+import { createVNode, defineComponent, mergeProps, ref } from "vue";
+
+//#region src/radio/radioButton.tsx
+const RadioButton = /* @__PURE__ */ defineComponent((props, { slots, attrs }) => {
+	const { prefixCls } = useComponentBaseConfig("radio", props);
+	useRadioOptionTypeContextProvider(ref("button"));
+	return () => {
+		return createVNode(radio_default, mergeProps({ "prefixCls": prefixCls.value }, attrs, props), slots);
+	};
+}, {
+	emits: [
+		"change",
+		"update:checked",
+		"update:value",
+		"mouseenter",
+		"mouseleave",
+		"keypress",
+		"keydown",
+		"focus",
+		"blur",
+		"click"
+	],
+	props: {
+		defaultChecked: {
+			type: Boolean,
+			required: false
+		},
+		checked: {
+			type: Boolean,
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		title: {
+			type: String,
+			required: false
+		},
+		value: { required: false },
+		tabIndex: {
+			type: Number,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		id: {
+			type: String,
+			required: false
+		},
+		autoFocus: {
+			type: Boolean,
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		skipGroup: {
+			type: Boolean,
+			required: false
+		},
+		required: {
+			type: Boolean,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	},
+	name: "ARadioButton",
+	inheritAttrs: false
+});
+var radioButton_default = RadioButton;
+
+//#endregion
+export { radioButton_default as default };

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

@@ -0,0 +1,82 @@
+import "../../theme/internal.js";
+import "vue";
+
+//#region src/radio/style/index.d.ts
+interface ComponentToken {
+  /**
+   * @desc 单选框大小
+   * @descEN Radio size
+   */
+  radioSize: number;
+  /**
+   * @desc 单选框圆点大小
+   * @descEN Size of Radio dot
+   */
+  dotSize: number;
+  /**
+   * @desc 单选框圆点禁用颜色
+   * @descEN Color of disabled Radio dot
+   */
+  dotColorDisabled: string;
+  /**
+   * @desc 单选框按钮背景色
+   * @descEN Background color of Radio button
+   */
+  buttonBg: string;
+  /**
+   * @desc 单选框按钮选中背景色
+   * @descEN Background color of checked Radio button
+   */
+  buttonCheckedBg: string;
+  /**
+   * @desc 单选框按钮文本颜色
+   * @descEN Color of Radio button text
+   */
+  buttonColor: string;
+  /**
+   * @desc 单选框按钮横向内间距
+   * @descEN Horizontal padding of Radio button
+   */
+  buttonPaddingInline: number;
+  /**
+   * @desc 单选框按钮选中并禁用时的背景色
+   * @descEN Background color of checked and disabled Radio button
+   */
+  buttonCheckedBgDisabled: string;
+  /**
+   * @desc 单选框按钮选中并禁用时的文本颜色
+   * @descEN Color of checked and disabled Radio button text
+   */
+  buttonCheckedColorDisabled: string;
+  /**
+   * @desc 单选框实色按钮选中时的文本颜色
+   * @descEN Color of checked solid Radio button text
+   */
+  buttonSolidCheckedColor: string;
+  /**
+   * @desc 单选框实色按钮选中时的背景色
+   * @descEN Background color of checked solid Radio button text
+   */
+  buttonSolidCheckedBg: string;
+  /**
+   * @desc 单选框实色按钮选中时的悬浮态背景色
+   * @descEN Background color of checked solid Radio button text when hover
+   */
+  buttonSolidCheckedHoverBg: string;
+  /**
+   * @desc 单选框实色按钮选中时的激活态背景色
+   * @descEN Background color of checked solid Radio button text when active
+   */
+  buttonSolidCheckedActiveBg: string;
+  /**
+   * @desc 单选框右间距
+   * @descEN Margin right of Radio button
+   */
+  wrapperMarginInlineEnd: number;
+  /** @internal */
+  radioColor: string;
+  /** @internal */
+  radioBgColor: string;
+}
+//#endregion
+export { ComponentToken };

package/dist/radio/style/index.js

@@ -0,0 +1,326 @@
+import { genFocusOutline, resetComponent } from "../../style/index.js";
+import { genStyleHooks } from "../../theme/util/genStyleUtils.js";
+import { mergeToken } from "../../theme/internal.js";
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/radio/style/index.ts
+const getGroupRadioStyle = (token) => {
+	const { componentCls, antCls } = token;
+	const groupPrefixCls = `${componentCls}-group`;
+	return { [groupPrefixCls]: {
+		...resetComponent(token),
+		"display": "inline-block",
+		"fontSize": 0,
+		[`&${groupPrefixCls}-rtl`]: { direction: "rtl" },
+		[`&${groupPrefixCls}-block`]: { display: "flex" },
+		[`${antCls}-badge ${antCls}-badge-count`]: { zIndex: 1 },
+		[`> ${antCls}-badge:not(:first-child) > ${antCls}-button-wrapper`]: { borderInlineStart: "none" },
+		"&-vertical": {
+			display: "flex",
+			flexDirection: "column",
+			rowGap: token.marginXS
+		}
+	} };
+};
+const getRadioBasicStyle = (token) => {
+	const { componentCls, wrapperMarginInlineEnd, colorPrimary, radioSize, motionDurationSlow, motionDurationMid, motionEaseInOutCirc, colorBgContainer, colorBorder, lineWidth, colorBgContainerDisabled, colorTextDisabled, paddingXS, dotColorDisabled, lineType, radioColor, radioBgColor, calc } = token;
+	const radioInnerPrefixCls = `${componentCls}-inner`;
+	const radioDotDisabledSize = calc(radioSize).sub(calc(4).mul(2));
+	const radioSizeCalc = calc(1).mul(radioSize).equal({ unit: true });
+	return { [`${componentCls}-wrapper`]: {
+		...resetComponent(token),
+		"display": "inline-flex",
+		"alignItems": "baseline",
+		"marginInlineStart": 0,
+		"marginInlineEnd": wrapperMarginInlineEnd,
+		"cursor": "pointer",
+		"&:last-child": { marginInlineEnd: 0 },
+		[`&${componentCls}-wrapper-rtl`]: { direction: "rtl" },
+		"&-disabled": {
+			cursor: "not-allowed",
+			color: token.colorTextDisabled
+		},
+		"&::after": {
+			display: "inline-block",
+			width: 0,
+			overflow: "hidden",
+			content: "\"\\a0\""
+		},
+		"&-block": {
+			flex: 1,
+			justifyContent: "center"
+		},
+		[`${componentCls}-checked::after`]: {
+			position: "absolute",
+			insetBlockStart: 0,
+			insetInlineStart: 0,
+			width: "100%",
+			height: "100%",
+			border: `${unit(lineWidth)} ${lineType} ${colorPrimary}`,
+			borderRadius: "50%",
+			visibility: "hidden",
+			opacity: 0,
+			content: "\"\""
+		},
+		[componentCls]: {
+			...resetComponent(token),
+			position: "relative",
+			display: "inline-block",
+			outline: "none",
+			cursor: "pointer",
+			alignSelf: "center",
+			borderRadius: "50%"
+		},
+		[`${componentCls}-wrapper:hover &,
+        &:hover ${radioInnerPrefixCls}`]: { borderColor: colorPrimary },
+		[`${componentCls}-input:focus-visible + ${radioInnerPrefixCls}`]: genFocusOutline(token),
+		[`${componentCls}:hover::after, ${componentCls}-wrapper:hover &::after`]: { visibility: "visible" },
+		[`${componentCls}-inner`]: {
+			"&::after": {
+				boxSizing: "border-box",
+				position: "absolute",
+				insetBlockStart: "50%",
+				insetInlineStart: "50%",
+				display: "block",
+				width: radioSizeCalc,
+				height: radioSizeCalc,
+				marginBlockStart: calc(1).mul(radioSize).div(-2).equal({ unit: true }),
+				marginInlineStart: calc(1).mul(radioSize).div(-2).equal({ unit: true }),
+				backgroundColor: radioColor,
+				borderBlockStart: 0,
+				borderInlineStart: 0,
+				borderRadius: radioSizeCalc,
+				transform: "scale(0)",
+				opacity: 0,
+				transition: `all ${motionDurationSlow} ${motionEaseInOutCirc}`,
+				content: "\"\""
+			},
+			"boxSizing": "border-box",
+			"position": "relative",
+			"insetBlockStart": 0,
+			"insetInlineStart": 0,
+			"display": "block",
+			"width": radioSizeCalc,
+			"height": radioSizeCalc,
+			"backgroundColor": colorBgContainer,
+			"borderColor": colorBorder,
+			"borderStyle": "solid",
+			"borderWidth": lineWidth,
+			"borderRadius": "50%",
+			"transition": `all ${motionDurationMid}`
+		},
+		[`${componentCls}-input`]: {
+			position: "absolute",
+			inset: 0,
+			zIndex: 1,
+			cursor: "pointer",
+			opacity: 0
+		},
+		[`${componentCls}-checked`]: { [radioInnerPrefixCls]: {
+			"borderColor": colorPrimary,
+			"backgroundColor": radioBgColor,
+			"&::after": {
+				transform: `scale(${token.calc(token.dotSize).div(radioSize).equal()})`,
+				opacity: 1,
+				transition: `all ${motionDurationSlow} ${motionEaseInOutCirc}`
+			}
+		} },
+		[`${componentCls}-disabled`]: {
+			cursor: "not-allowed",
+			[radioInnerPrefixCls]: {
+				"backgroundColor": colorBgContainerDisabled,
+				"borderColor": colorBorder,
+				"cursor": "not-allowed",
+				"&::after": { backgroundColor: dotColorDisabled }
+			},
+			[`${componentCls}-input`]: { cursor: "not-allowed" },
+			[`${componentCls}-disabled + span`]: {
+				color: colorTextDisabled,
+				cursor: "not-allowed"
+			},
+			[`&${componentCls}-checked`]: { [radioInnerPrefixCls]: { "&::after": { transform: `scale(${calc(radioDotDisabledSize).div(radioSize).equal()})` } } }
+		},
+		[`span${componentCls} + *`]: {
+			paddingInlineStart: paddingXS,
+			paddingInlineEnd: paddingXS
+		}
+	} };
+};
+const getRadioButtonStyle = (token) => {
+	const { buttonColor, controlHeight, componentCls, lineWidth, lineType, colorBorder, motionDurationMid, buttonPaddingInline, fontSize, buttonBg, fontSizeLG, controlHeightLG, controlHeightSM, paddingXS, borderRadius, borderRadiusSM, borderRadiusLG, buttonCheckedBg, buttonSolidCheckedColor, colorTextDisabled, colorBgContainerDisabled, buttonCheckedBgDisabled, buttonCheckedColorDisabled, colorPrimary, colorPrimaryHover, colorPrimaryActive, buttonSolidCheckedBg, buttonSolidCheckedHoverBg, buttonSolidCheckedActiveBg, calc } = token;
+	return { [`${componentCls}-button-wrapper`]: {
+		"position": "relative",
+		"display": "inline-block",
+		"height": controlHeight,
+		"margin": 0,
+		"paddingInline": buttonPaddingInline,
+		"paddingBlock": 0,
+		"color": buttonColor,
+		fontSize,
+		"lineHeight": unit(calc(controlHeight).sub(calc(lineWidth).mul(2)).equal()),
+		"background": buttonBg,
+		"border": `${unit(lineWidth)} ${lineType} ${colorBorder}`,
+		"borderBlockStartWidth": calc(lineWidth).add(.02).equal(),
+		"borderInlineEndWidth": lineWidth,
+		"cursor": "pointer",
+		"transition": [
+			`color ${motionDurationMid}`,
+			`background ${motionDurationMid}`,
+			`box-shadow ${motionDurationMid}`
+		].join(","),
+		"a": { color: buttonColor },
+		[`> ${componentCls}-button`]: {
+			position: "absolute",
+			insetBlockStart: 0,
+			insetInlineStart: 0,
+			zIndex: -1,
+			width: "100%",
+			height: "100%"
+		},
+		"&:not(:last-child)": { marginInlineEnd: calc(lineWidth).mul(-1).equal() },
+		"&:first-child": {
+			borderInlineStart: `${unit(lineWidth)} ${lineType} ${colorBorder}`,
+			borderStartStartRadius: borderRadius,
+			borderEndStartRadius: borderRadius
+		},
+		"&:last-child": {
+			borderStartEndRadius: borderRadius,
+			borderEndEndRadius: borderRadius
+		},
+		"&:first-child:last-child": { borderRadius },
+		[`${componentCls}-group-large &`]: {
+			"height": controlHeightLG,
+			"fontSize": fontSizeLG,
+			"lineHeight": unit(calc(controlHeightLG).sub(calc(lineWidth).mul(2)).equal()),
+			"&:first-child": {
+				borderStartStartRadius: borderRadiusLG,
+				borderEndStartRadius: borderRadiusLG
+			},
+			"&:last-child": {
+				borderStartEndRadius: borderRadiusLG,
+				borderEndEndRadius: borderRadiusLG
+			}
+		},
+		[`${componentCls}-group-small &`]: {
+			"height": controlHeightSM,
+			"paddingInline": calc(paddingXS).sub(lineWidth).equal(),
+			"paddingBlock": 0,
+			"lineHeight": unit(calc(controlHeightSM).sub(calc(lineWidth).mul(2)).equal()),
+			"&:first-child": {
+				borderStartStartRadius: borderRadiusSM,
+				borderEndStartRadius: borderRadiusSM
+			},
+			"&:last-child": {
+				borderStartEndRadius: borderRadiusSM,
+				borderEndEndRadius: borderRadiusSM
+			}
+		},
+		"&:hover": {
+			position: "relative",
+			color: colorPrimary
+		},
+		"&:has(:focus-visible)": genFocusOutline(token),
+		[`${componentCls}-inner, input[type='checkbox'], input[type='radio']`]: {
+			width: 0,
+			height: 0,
+			opacity: 0,
+			pointerEvents: "none"
+		},
+		[`&-checked:not(${componentCls}-button-wrapper-disabled)`]: {
+			"zIndex": 1,
+			"color": colorPrimary,
+			"background": buttonCheckedBg,
+			"borderColor": colorPrimary,
+			"&::before": { backgroundColor: colorPrimary },
+			"&:first-child": { borderColor: colorPrimary },
+			"&:hover": {
+				"color": colorPrimaryHover,
+				"borderColor": colorPrimaryHover,
+				"&::before": { backgroundColor: colorPrimaryHover }
+			},
+			"&:active": {
+				"color": colorPrimaryActive,
+				"borderColor": colorPrimaryActive,
+				"&::before": { backgroundColor: colorPrimaryActive }
+			}
+		},
+		[`${componentCls}-group-solid &-checked:not(${componentCls}-button-wrapper-disabled)`]: {
+			"color": buttonSolidCheckedColor,
+			"background": buttonSolidCheckedBg,
+			"borderColor": buttonSolidCheckedBg,
+			"&:hover": {
+				color: buttonSolidCheckedColor,
+				background: buttonSolidCheckedHoverBg,
+				borderColor: buttonSolidCheckedHoverBg
+			},
+			"&:active": {
+				color: buttonSolidCheckedColor,
+				background: buttonSolidCheckedActiveBg,
+				borderColor: buttonSolidCheckedActiveBg
+			}
+		},
+		"&-disabled": {
+			"color": colorTextDisabled,
+			"backgroundColor": colorBgContainerDisabled,
+			"borderColor": colorBorder,
+			"cursor": "not-allowed",
+			"&:first-child, &:hover": {
+				color: colorTextDisabled,
+				backgroundColor: colorBgContainerDisabled,
+				borderColor: colorBorder
+			}
+		},
+		[`&-disabled${componentCls}-button-wrapper-checked`]: {
+			color: buttonCheckedColorDisabled,
+			backgroundColor: buttonCheckedBgDisabled,
+			borderColor: colorBorder,
+			boxShadow: "none"
+		},
+		"&-block": {
+			flex: 1,
+			textAlign: "center"
+		}
+	} };
+};
+const prepareComponentToken = (token) => {
+	const { wireframe, padding, marginXS, lineWidth, fontSizeLG, colorText, colorBgContainer, colorTextDisabled, controlItemBgActiveDisabled, colorTextLightSolid, colorPrimary, colorPrimaryHover, colorPrimaryActive, colorWhite } = token;
+	const dotPadding = 4;
+	const radioSize = fontSizeLG;
+	return {
+		radioSize,
+		dotSize: wireframe ? radioSize - dotPadding * 2 : radioSize - (dotPadding + lineWidth) * 2,
+		dotColorDisabled: colorTextDisabled,
+		buttonSolidCheckedColor: colorTextLightSolid,
+		buttonSolidCheckedBg: colorPrimary,
+		buttonSolidCheckedHoverBg: colorPrimaryHover,
+		buttonSolidCheckedActiveBg: colorPrimaryActive,
+		buttonBg: colorBgContainer,
+		buttonCheckedBg: colorBgContainer,
+		buttonColor: colorText,
+		buttonCheckedBgDisabled: controlItemBgActiveDisabled,
+		buttonCheckedColorDisabled: colorTextDisabled,
+		buttonPaddingInline: padding - lineWidth,
+		wrapperMarginInlineEnd: marginXS,
+		radioColor: wireframe ? colorPrimary : colorWhite,
+		radioBgColor: wireframe ? colorBgContainer : colorPrimary
+	};
+};
+var style_default = genStyleHooks("Radio", (token) => {
+	const { controlOutline, controlOutlineWidth } = token;
+	const radioFocusShadow = `0 0 0 ${unit(controlOutlineWidth)} ${controlOutline}`;
+	const radioToken = mergeToken(token, {
+		radioFocusShadow,
+		radioButtonFocusShadow: radioFocusShadow
+	});
+	return [
+		getGroupRadioStyle(radioToken),
+		getRadioBasicStyle(radioToken),
+		getRadioButtonStyle(radioToken)
+	];
+}, prepareComponentToken, { unitless: {
+	radioSize: true,
+	dotSize: true
+} });
+
+//#endregion
+export { style_default as default };