antdv-next 0.0.111 → 1.0.0-alpha.2

package/dist/qrcode/index.d.ts

@@ -0,0 +1,10 @@
+import { QRCodeEmits, QRCodeProps, QRCodeSlots } from "./interface.js";
+import * as vue192 from "vue";
+import { SlotsType } from "vue";
+
+//#region src/qrcode/index.d.ts
+declare const QRCode: vue192.DefineSetupFnComponent<QRCodeProps, QRCodeEmits, SlotsType<QRCodeSlots>, QRCodeProps & {
+  [x: `on${Capitalize<string>}`]: (() => any) | undefined;
+}, vue192.PublicProps>;
+//#endregion
+export { QRCode };

package/dist/qrcode/index.js

@@ -0,0 +1,207 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import useToken from "../theme/useToken.js";
+import "../theme/internal.js";
+import { 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 useLocale_default from "../locale/useLocale.js";
+import QrcodeStatus_default from "./QrcodeStatus.js";
+import style_default from "./style/index.js";
+import { computed, createVNode, defineComponent, mergeDefaults, mergeProps } from "vue";
+import { classNames } from "@v-c/util";
+import { omit } from "es-toolkit";
+import pickAttrs from "@v-c/util/dist/pickAttrs";
+import { QRCodeCanvas, QRCodeSVG } from "@v-c/qrcode";
+
+//#region src/qrcode/index.tsx
+const QRCode = /* @__PURE__ */ defineComponent((props, { emit, attrs, slots }) => {
+	const { prefixCls, class: contextClassName, style: contextStyle, classes: contextClassNames, styles: contextStyles } = useComponentBaseConfig("qrcode", props);
+	const { styles, classes } = toPropsRefs(props, "styles", "classes");
+	const [hashId, cssVarCls] = style_default(prefixCls);
+	const [locale] = useLocale_default("QRCode");
+	const [, token] = useToken();
+	const color = computed(() => props.color ?? token.value.colorText);
+	const imageSettings = computed(() => {
+		const { icon, iconSize } = props;
+		return {
+			src: icon,
+			x: void 0,
+			y: void 0,
+			height: typeof iconSize === "number" ? iconSize : iconSize?.height ?? 40,
+			width: typeof iconSize === "number" ? iconSize : iconSize?.width ?? 40,
+			excavate: true,
+			crossOrigin: "anonymous"
+		};
+	});
+	const mergedProps = computed(() => {
+		return props;
+	});
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(contextClassNames, classes), useToArr(contextStyles, styles), useToProps(mergedProps));
+	return () => {
+		const { type, value, size, errorLevel, bgColor, icon, boostLevel, bordered, rootClass, status } = props;
+		const statusRender = slots?.statusRender ?? props?.statusRender;
+		const a11yProps = pickAttrs(attrs, true);
+		const restProps = omit(attrs, Object.keys(a11yProps));
+		const style = attrs.style;
+		const cls = attrs.class;
+		const qrCodeProps = {
+			value,
+			size,
+			level: errorLevel,
+			bgColor,
+			fgColor: color.value,
+			style: {
+				width: style?.width,
+				height: style?.height
+			},
+			imageSettings: icon ? imageSettings.value : void 0,
+			boostLevel,
+			...a11yProps
+		};
+		if (isDev) {
+			const warning = devUseWarning("QRCode");
+			warning(!!value, "usage", "need to receive `value` props");
+			warning(!(icon && errorLevel === "L"), "usage", "ErrorLevel `L` is not recommended to be used with `icon`, for scanning result would be affected by low level.");
+		}
+		if (!value) return null;
+		const mergedCls = classNames(prefixCls.value, cls, rootClass, hashId.value, cssVarCls.value, contextClassName.value, mergedClassNames.value.root, { [`${prefixCls.value}-borderless`]: !bordered });
+		let _width = style?.width ?? size;
+		let _height = style?.height ?? size;
+		if (typeof _width === "number") _width = `${_width}px`;
+		if (typeof _height === "number") _height = `${_height}px`;
+		const rootStyle = {
+			backgroundColor: bgColor,
+			...mergedStyles.value?.root,
+			...contextStyle.value,
+			...style,
+			width: _width,
+			height: _height
+		};
+		return createVNode("div", mergeProps(restProps, {
+			"class": mergedCls,
+			"style": rootStyle
+		}), [status !== "active" && createVNode("div", {
+			"class": [`${prefixCls.value}-cover`, mergedClassNames.value.cover],
+			"style": mergedStyles.value.cover
+		}, [createVNode(QrcodeStatus_default, {
+			"prefixCls": prefixCls.value,
+			"locale": locale.value,
+			"status": status,
+			"onRefresh": () => {
+				emit("refresh");
+			},
+			"statusRender": statusRender
+		}, null)]), type === "canvas" ? createVNode(QRCodeCanvas, qrCodeProps, null) : createVNode(QRCodeSVG, qrCodeProps, null)]);
+	};
+}, {
+	emits: ["refresh"],
+	props: /* @__PURE__ */ mergeDefaults({
+		type: {
+			type: String,
+			required: false
+		},
+		icon: {
+			type: String,
+			required: false
+		},
+		iconSize: {
+			type: [Number, Object],
+			required: false
+		},
+		bordered: {
+			type: Boolean,
+			required: false
+		},
+		errorLevel: {
+			type: String,
+			required: false
+		},
+		status: {
+			type: String,
+			required: false
+		},
+		statusRender: {
+			type: Function,
+			required: false
+		},
+		color: { required: false },
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		value: {
+			type: [String, Array],
+			required: true
+		},
+		boostLevel: {
+			type: Boolean,
+			required: false
+		},
+		size: {
+			type: Number,
+			required: false
+		},
+		level: {
+			type: String,
+			required: false
+		},
+		bgColor: {
+			type: String,
+			required: false
+		},
+		fgColor: {
+			type: String,
+			required: false
+		},
+		includeMargin: {
+			type: Boolean,
+			required: false
+		},
+		marginSize: {
+			type: Number,
+			required: false
+		},
+		imageSettings: {
+			type: Object,
+			required: false
+		},
+		title: {
+			type: String,
+			required: false
+		},
+		minVersion: {
+			type: Number,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	}, {
+		type: "canvas",
+		icon: "",
+		size: 160,
+		bordered: true,
+		errorLevel: "M",
+		status: "active",
+		bgColor: "transparent"
+	}),
+	name: "AQrcode",
+	inheritAttrs: false
+});
+QRCode.install = (app) => {
+	app.component(QRCode.name, QRCode);
+};
+var qrcode_default = QRCode;
+
+//#endregion
+export { qrcode_default as default };

package/dist/qrcode/interface.d.ts

@@ -0,0 +1,40 @@
+import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { Locale } from "../locale/index.js";
+import { ComponentBaseProps } from "../config-provider/context.js";
+import { QRProps } from "@v-c/qrcode";
+
+//#region src/qrcode/interface.d.ts
+type QRStatus = 'active' | 'expired' | 'loading' | 'scanned';
+interface StatusRenderInfo {
+  status: Exclude<QRStatus, 'active'>;
+  locale: Locale['QRCode'];
+  onRefresh?: () => void;
+}
+type QRCodeSemanticName = 'root' | 'cover';
+type QRCodeClassNamesType = SemanticClassNamesType<QRCodeProps, QRCodeSemanticName>;
+type QRCodeStylesType = SemanticStylesType<QRCodeProps, QRCodeSemanticName>;
+interface QRCodeProps extends QRProps, ComponentBaseProps {
+  type?: 'canvas' | 'svg';
+  icon?: string;
+  iconSize?: number | {
+    width: number;
+    height: number;
+  };
+  bordered?: boolean;
+  errorLevel?: 'L' | 'M' | 'Q' | 'H';
+  status?: QRStatus;
+  statusRender?: (info: StatusRenderInfo) => any;
+  color?: any;
+  classes?: QRCodeClassNamesType;
+  styles?: QRCodeStylesType;
+}
+interface QRCodeSlots {
+  statusRender?: (info: StatusRenderInfo) => any;
+}
+interface QRCodeEmits {
+  refresh: () => void;
+  [key: string]: () => any;
+}
+//#endregion
+export { QRCodeEmits, QRCodeProps, QRCodeSlots };

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

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

package/dist/qrcode/style/index.js

@@ -0,0 +1,62 @@
+import { resetComponent } from "../../style/index.js";
+import { genStyleHooks } from "../../theme/util/genStyleUtils.js";
+import { mergeToken } from "../../theme/internal.js";
+import { unit } from "@antdv-next/cssinjs";
+import { FastColor } from "@ant-design/fast-color";
+
+//#region src/qrcode/style/index.ts
+const genQRCodeStyle = (token) => {
+	const { componentCls, lineWidth, lineType, colorSplit } = token;
+	return {
+		[componentCls]: {
+			...resetComponent(token),
+			"display": "flex",
+			"justifyContent": "center",
+			"alignItems": "center",
+			"padding": token.paddingSM,
+			"backgroundColor": token.colorWhite,
+			"borderRadius": token.borderRadiusLG,
+			"border": `${unit(lineWidth)} ${lineType} ${colorSplit}`,
+			"position": "relative",
+			"overflow": "hidden",
+			[`& > ${componentCls}-cover`]: {
+				position: "absolute",
+				insetBlockStart: 0,
+				insetInlineStart: 0,
+				zIndex: 10,
+				display: "flex",
+				flexDirection: "column",
+				justifyContent: "center",
+				alignItems: "center",
+				width: "100%",
+				height: "100%",
+				color: token.colorText,
+				lineHeight: token.lineHeight,
+				background: token.QRCodeCoverBackgroundColor,
+				textAlign: "center",
+				[`& > ${componentCls}-expired, & > ${componentCls}-scanned`]: { color: token.QRCodeTextColor }
+			},
+			"> canvas": {
+				alignSelf: "stretch",
+				flex: "auto",
+				minWidth: 0
+			},
+			"&-icon": {
+				marginBlockEnd: token.marginXS,
+				fontSize: token.controlHeight
+			}
+		},
+		[`${componentCls}-borderless`]: {
+			borderColor: "transparent",
+			padding: 0,
+			borderRadius: 0
+		}
+	};
+};
+const prepareComponentToken = (token) => ({ QRCodeCoverBackgroundColor: new FastColor(token.colorBgContainer).setA(.96).toRgbString() });
+var style_default = genStyleHooks("QRCode", (token) => {
+	return genQRCodeStyle(mergeToken(token, { QRCodeTextColor: token.colorText }));
+}, prepareComponentToken);
+
+//#endregion
+export { style_default as default };

package/dist/radio/context.js

@@ -0,0 +1,20 @@
+import { inject, provide } from "vue";
+
+//#region src/radio/context.ts
+const RadioGroupContextKey = Symbol("RadioGroupContextKey");
+function useRadioGroupContextProvider(value) {
+	provide(RadioGroupContextKey, value);
+}
+function useRadioGroupContext() {
+	return inject(RadioGroupContextKey, void 0);
+}
+const RadioOptionTypeContextKey = Symbol("RadioOptionTypeContext");
+function useRadioOptionTypeContextProvider(value) {
+	provide(RadioOptionTypeContextKey, value);
+}
+function useRadioOptionTypeContext() {
+	return inject(RadioOptionTypeContextKey, void 0);
+}
+
+//#endregion
+export { useRadioGroupContext, useRadioGroupContextProvider, useRadioOptionTypeContext, useRadioOptionTypeContextProvider };

package/dist/radio/group.js

@@ -0,0 +1,199 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import { getAttrStyleAndClass as getAttrStyleAndClass$1 } from "../_util/hooks/useMergeSemantic.js";
+import { useOrientation } from "../_util/hooks/useOrientation.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 { useSize } from "../config-provider/hooks/useSize.js";
+import { useFormItemContext, useFormItemInputContext } from "../form/context.js";
+import { toNamePathStr } from "../form/hooks/useForm.js";
+import { useRadioGroupContextProvider } from "./context.js";
+import style_default from "./style/index.js";
+import radio_default from "./radio.js";
+import { computed, createVNode, defineComponent, isVNode, mergeDefaults, mergeProps, ref, useId, watch } from "vue";
+import { clsx } from "@v-c/util";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import pickAttrs from "@v-c/util/dist/pickAttrs";
+
+//#region src/radio/group.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const RadioGroup = /* @__PURE__ */ defineComponent((props, { slots, attrs, emit }) => {
+	const { prefixCls, direction } = useComponentBaseConfig("radio", props);
+	const formItemInputContext = useFormItemInputContext();
+	const defaultName = computed(() => toNamePathStr(formItemInputContext.value?.name ?? "") || useId());
+	const name = computed(() => props?.name ?? defaultName.value);
+	const { size: customizeSize, orientation, vertical } = toPropsRefs(props, "size", "orientation", "vertical");
+	const formItemContext = useFormItemContext(true);
+	const value = ref(props?.value ?? props?.defaultValue);
+	const onRadioChange = (e) => {
+		const lastValue = value.value;
+		const val = e.target.value;
+		if (props.value !== void 0) value.value = val;
+		if (val !== lastValue) {
+			emit("change", e);
+			emit("update:value", val);
+		}
+	};
+	watch(() => props.value, () => {
+		if (props.value !== void 0) value.value = props.value;
+	});
+	const groupPrefixCls = computed(() => `${prefixCls.value}-group`);
+	const rootCls = useCSSVarCls_default(prefixCls);
+	const [hashId, cssVarCls] = style_default(prefixCls, rootCls);
+	const mergedSize = useSize(customizeSize);
+	const [, mergedVertical] = useOrientation(orientation, vertical);
+	useRadioGroupContextProvider(computed(() => {
+		return {
+			onChange: onRadioChange,
+			value: value.value,
+			disabled: props?.disabled,
+			name: name.value,
+			optionType: props?.optionType,
+			block: props?.block
+		};
+	}));
+	return () => {
+		const { buttonStyle, block, rootClass, id, options, disabled } = props;
+		const children = checkRenderNode(filterEmpty(slots?.default?.() ?? []));
+		const { className, restAttrs, style } = getAttrStyleAndClass$1(attrs);
+		const classString = clsx(groupPrefixCls.value, `${groupPrefixCls.value}-${buttonStyle}`, {
+			[`${groupPrefixCls.value}-${mergedSize.value}`]: mergedSize.value,
+			[`${groupPrefixCls.value}-rtl`]: direction.value === "rtl",
+			[`${groupPrefixCls.value}-block`]: block
+		}, className, rootClass, hashId.value, cssVarCls.value, rootCls.value);
+		let childrenToRender = children;
+		const labelRender = slots?.labelRender ?? props?.labelRender;
+		if (options && options.length) childrenToRender = options.map((option, index) => {
+			if (typeof option === "string" || typeof option === "number") {
+				const _label$1 = labelRender ? labelRender({
+					item: {
+						label: option,
+						value: option
+					},
+					index
+				}) : option;
+				return createVNode(radio_default, {
+					"key": option.toString(),
+					"prefixCls": prefixCls.value,
+					"disabled": disabled,
+					"value": option,
+					"checked": value.value === option
+				}, _isSlot(_label$1) ? _label$1 : { default: () => [_label$1] });
+			}
+			const _label = labelRender ? labelRender({
+				item: option,
+				index
+			}) : option.label;
+			return createVNode(radio_default, {
+				"key": `radio-group-value-options-${option.value}`,
+				"prefixCls": prefixCls.value,
+				"disabled": option.disabled || disabled,
+				"value": option.value,
+				"checked": value.value === option.value,
+				"title": option.title,
+				"style": option.style,
+				"class": option.class,
+				"id": option.id,
+				"required": option.required
+			}, _isSlot(_label) ? _label : { default: () => [_label] });
+		});
+		return createVNode("div", mergeProps(pickAttrs(restAttrs, {
+			aria: true,
+			data: true
+		}), {
+			"class": clsx(classString, { [`${prefixCls.value}-group-vertical`]: mergedVertical.value }),
+			"style": style,
+			"onMouseenter": (e) => {
+				emit("mouseenter", e);
+			},
+			"onMouseleave": (e) => {
+				emit("mouseleave", e);
+			},
+			"onFocus": (e) => {
+				emit("focus", e);
+			},
+			"onBlur": (e) => {
+				emit("blur", e);
+				formItemContext?.triggerBlur?.();
+			},
+			"id": id
+		}), [childrenToRender]);
+	};
+}, {
+	emits: [
+		"change",
+		"mouseenter",
+		"mouseleave",
+		"focus",
+		"blur",
+		"update:value"
+	],
+	props: /* @__PURE__ */ mergeDefaults({
+		defaultValue: { required: false },
+		value: { required: false },
+		size: {
+			type: [String, null],
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		name: {
+			type: String,
+			required: false
+		},
+		id: {
+			type: String,
+			required: false
+		},
+		optionType: {
+			type: String,
+			required: false
+		},
+		orientation: {
+			type: String,
+			required: false
+		},
+		buttonStyle: {
+			type: String,
+			required: false
+		},
+		block: {
+			type: Boolean,
+			required: false
+		},
+		vertical: {
+			type: Boolean,
+			required: false
+		},
+		labelRender: {
+			type: Function,
+			required: false
+		},
+		options: {
+			type: Array,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	}, {
+		buttonStyle: "outline",
+		block: false
+	}),
+	name: "ARadioGroup",
+	inheritAttrs: false
+});
+var group_default = RadioGroup;
+
+//#endregion
+export { group_default as default };

package/dist/radio/index.d.ts

@@ -0,0 +1,18 @@
+import { AbstractCheckboxProps, CheckboxEmits, CheckboxSlots } from "../checkbox/Checkbox.js";
+import { CheckboxOptionType } from "../checkbox/Group.js";
+import "../checkbox/index.js";
+import { RadioChangeEvent, RadioEmits, RadioGroupEmits, RadioGroupOptionType, RadioGroupProps, RadioGroupSlots, RadioProps, RadioSlots } from "./interface.js";
+import { InternalRadio } from "./radio.js";
+import "../index.js";
+import * as vue180 from "vue";
+
+//#region src/radio/index.d.ts
+type RadioOptionType = CheckboxOptionType;
+declare const RadioGroup: vue180.DefineSetupFnComponent<RadioGroupProps, RadioGroupEmits, vue180.SlotsType<RadioGroupSlots>, RadioGroupProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue180.PublicProps>;
+declare const RadioButton: vue180.DefineSetupFnComponent<AbstractCheckboxProps, CheckboxEmits, vue180.SlotsType<CheckboxSlots>, AbstractCheckboxProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue180.PublicProps>;
+//#endregion
+export { RadioButton, RadioGroup, RadioOptionType };

package/dist/radio/index.js

@@ -0,0 +1,19 @@
+import radio_default from "./radio.js";
+import group_default from "./group.js";
+import radioButton_default from "./radioButton.js";
+
+//#region src/radio/index.tsx
+const RadioGroup = group_default;
+const RadioButton = radioButton_default;
+radio_default.Button = radioButton_default;
+radio_default.Group = group_default;
+radio_default.__ANT_RADIO = true;
+radio_default.install = (app) => {
+	app.component(radio_default.name, radio_default);
+	app.component(RadioGroup.name, RadioGroup);
+	app.component(RadioButton.name, RadioButton);
+};
+var radio_default$1 = radio_default;
+
+//#endregion
+export { RadioButton, RadioGroup, radio_default$1 as default };

package/dist/radio/interface.d.ts

@@ -0,0 +1,72 @@
+import { SizeType } from "../config-provider/SizeContext.js";
+import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import { Orientation } from "../_util/hooks/useOrientation.js";
+import "../_util/hooks/index.js";
+import { AbstractCheckboxProps, CheckboxEmits } from "../checkbox/Checkbox.js";
+import { AbstractCheckboxGroupProps, CheckboxOptionType } from "../checkbox/Group.js";
+
+//#region src/radio/interface.d.ts
+type RadioGroupButtonStyle = 'outline' | 'solid';
+type RadioGroupOptionType = 'default' | 'button';
+interface RadioGroupProps extends AbstractCheckboxGroupProps {
+  defaultValue?: any;
+  value?: any;
+  size?: SizeType;
+  disabled?: boolean;
+  name?: string;
+  id?: string;
+  optionType?: RadioGroupOptionType;
+  orientation?: Orientation;
+  buttonStyle?: RadioGroupButtonStyle;
+  block?: boolean;
+  vertical?: boolean;
+  labelRender?: (params: {
+    item: CheckboxOptionType;
+    index: number;
+  }) => any;
+}
+interface RadioGroupEmits {
+  'change': (e: RadioChangeEvent) => void;
+  'mouseenter': (e: MouseEvent) => void;
+  'mouseleave': (e: MouseEvent) => void;
+  'focus': (e: FocusEvent) => void;
+  'blur': (e: FocusEvent) => void;
+  'update:value': (value: any) => void;
+  [key: string]: (...args: any[]) => void;
+}
+interface RadioGroupSlots {
+  default: () => any;
+  labelRender: (params: {
+    item: CheckboxOptionType;
+    index: number;
+  }) => any;
+}
+type RadioSemanticName = 'root' | 'icon' | 'label';
+type RadioClassNamesType = SemanticClassNamesType<RadioProps, RadioSemanticName>;
+type RadioStylesType = SemanticStylesType<RadioProps, RadioSemanticName>;
+interface RadioProps extends AbstractCheckboxProps {
+  /**
+   * Control the appearance for Radio to display as button or not
+   *
+   * @default 'default'
+   * @internal
+   */
+  optionType?: RadioGroupOptionType;
+  classes?: RadioClassNamesType;
+  styles?: RadioStylesType;
+}
+interface RadioEmits extends CheckboxEmits {}
+interface RadioSlots {
+  default?: () => any;
+}
+interface RadioChangeEventTarget extends RadioProps {
+  checked: boolean;
+}
+interface RadioChangeEvent {
+  target: RadioChangeEventTarget;
+  stopPropagation: () => void;
+  preventDefault: () => void;
+  nativeEvent: MouseEvent;
+}
+//#endregion
+export { RadioChangeEvent, RadioEmits, RadioGroupEmits, RadioGroupOptionType, RadioGroupProps, RadioGroupSlots, RadioProps, RadioSlots };

package/dist/radio/radio.d.ts

@@ -0,0 +1,10 @@
+import { RadioEmits, RadioProps, RadioSlots } from "./interface.js";
+import * as vue418 from "vue";
+import { SlotsType } from "vue";
+
+//#region src/radio/radio.d.ts
+declare const InternalRadio: vue418.DefineSetupFnComponent<RadioProps, RadioEmits, SlotsType<RadioSlots>, RadioProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue418.PublicProps>;
+//#endregion
+export { InternalRadio };