@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/radio/RadioGroup.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,147 @@
+import { useControlled } from "../_util/hooks/useControlled.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useDisabled, useSize } from "../config-provider/context.js";
+import { useFormItemInputContext } from "../form/context.js";
+import { radioGroupContextKey } from "./context.js";
+import Radio_default from "./Radio.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createElementBlock, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, provide, renderList, renderSlot, unref, useId, useSlots, withCtx } from "vue";
+// src/radio/RadioGroup.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"id",
+	"aria-orientation",
+	"aria-disabled"
+];
+var RadioGroup_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmRadioGroup",
+	inheritAttrs: false,
+	__name: "RadioGroup",
+	props: {
+		value: {},
+		defaultValue: {},
+		options: {},
+		optionType: {},
+		buttonStyle: { default: "outline" },
+		size: {},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		name: {},
+		id: {},
+		block: {
+			type: Boolean,
+			default: void 0
+		},
+		vertical: {
+			type: Boolean,
+			default: void 0
+		},
+		orientation: {},
+		labelRender: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["change", "update:value"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const formItem = useFormItemInputContext();
+		const disabled = useDisabled(() => props.disabled);
+		const size = useSize(() => props.size);
+		const defaultName = useId();
+		const [value, setValue] = useControlled(props, "value", {
+			defaultValue: () => props.defaultValue,
+			onChange: (val) => emit("update:value", val)
+		});
+		const mergedOptions = computed(() => (props.options ?? []).map((option) => typeof option === "string" || typeof option === "number" ? {
+			label: option,
+			value: option
+		} : option));
+		const isVertical = computed(() => props.vertical ?? props.orientation === "vertical");
+		const isButton = computed(() => props.optionType === "button");
+		function select(event) {
+			const next = event.target.value;
+			if (next === value.value) return;
+			setValue(next);
+			emit("change", event);
+			formItem.onFieldChange();
+		}
+		provide(radioGroupContextKey, {
+			value: computed(() => value.value),
+			disabled,
+			name: computed(() => props.name ?? defaultName),
+			optionType: computed(() => props.optionType),
+			buttonStyle: computed(() => props.buttonStyle),
+			size,
+			block: computed(() => props.block),
+			classes: computed(() => props.classes),
+			styles: computed(() => props.styles),
+			iconSlot: () => slots.icon,
+			select
+		});
+		const classNames = computed(() => [
+			"am-radio-group",
+			`am-radio-group-${props.buttonStyle}`,
+			{
+				"am-radio-group-button": isButton.value,
+				"am-radio-group-vertical": isVertical.value,
+				"am-radio-group-block": props.block,
+				"am-radio-group-sm": size.value === "small",
+				"am-radio-group-lg": size.value === "large",
+				"am-radio-group-disabled": disabled.value
+			},
+			props.rootClass,
+			props.classes?.root
+		]);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, {
+				id: __props.id ?? unref(formItem).id.value,
+				class: classNames.value,
+				style: __props.styles?.root,
+				role: "radiogroup",
+				"aria-orientation": isVertical.value ? "vertical" : "horizontal",
+				"aria-disabled": unref(disabled) || void 0
+			}), [mergedOptions.value.length ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(mergedOptions.value, (option, index) => {
+				return openBlock(), createBlock(Radio_default, {
+					id: option.id,
+					key: `${typeof option.value}-${option.value}`,
+					value: option.value,
+					disabled: option.disabled,
+					title: option.title,
+					required: option.required,
+					class: normalizeClass(option.class),
+					style: normalizeStyle(option.style)
+				}, {
+					default: withCtx(() => [renderSlot(_ctx.$slots, "labelRender", {
+						item: option,
+						index
+					}, () => [__props.labelRender ? (openBlock(), createBlock(unref(RenderNode_default), {
+						key: 0,
+						node: __props.labelRender,
+						params: {
+							item: option,
+							index
+						}
+					}, null, 8, ["node", "params"])) : (openBlock(), createBlock(unref(RenderNode_default), {
+						key: 1,
+						node: option.label
+					}, null, 8, ["node"]))])]),
+					_: 2
+				}, 1032, [
+					"id",
+					"value",
+					"disabled",
+					"title",
+					"required",
+					"class",
+					"style"
+				]);
+			}), 128)) : renderSlot(_ctx.$slots, "default", {}, void 0, void 0, 1)], 16, _hoisted_1);
+		};
+	}
+});
+export { RadioGroup_vue_vue_type_script_setup_true_lang_default as default };

package/dist/radio/context.d.ts

@@ -0,0 +1,18 @@
+import type { ComputedRef, InjectionKey, Slot } from 'vue';
+import type { SizeType } from '../_util/type';
+import type { RadioChangeEvent, RadioGroupButtonStyle, RadioGroupOptionType, RadioGroupSemanticClassNames, RadioGroupSemanticStyles } from './interface';
+export interface RadioGroupContext {
+    value: ComputedRef<any>;
+    disabled: ComputedRef<boolean>;
+    name: ComputedRef<string | undefined>;
+    optionType: ComputedRef<RadioGroupOptionType | undefined>;
+    buttonStyle: ComputedRef<RadioGroupButtonStyle>;
+    size: ComputedRef<SizeType>;
+    block: ComputedRef<boolean | undefined>;
+    classes: ComputedRef<RadioGroupSemanticClassNames | undefined>;
+    styles: ComputedRef<RadioGroupSemanticStyles | undefined>;
+    iconSlot: () => Slot | undefined;
+    select: (event: RadioChangeEvent) => void;
+}
+export declare const radioGroupContextKey: InjectionKey<RadioGroupContext>;
+export declare function useRadioGroupContext(): RadioGroupContext | undefined;

package/dist/radio/context.js

@@ -0,0 +1,7 @@
+import { inject } from "vue";
+// src/radio/context.ts
+var radioGroupContextKey = Symbol("AmRadioGroupContext");
+function useRadioGroupContext() {
+	return inject(radioGroupContextKey, void 0);
+}
+export { radioGroupContextKey, useRadioGroupContext };

package/dist/radio/index.d.ts

@@ -0,0 +1,321 @@
+export type * from './interface';
+export declare const RadioGroup: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").RadioGroupProps> & Readonly<{
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        "onUpdate:value"?: ((value: any) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (event: import("./interface").RadioChangeEvent) => any;
+        "update:value": (value: any) => any;
+    }, import("vue").PublicProps, {
+        block: boolean;
+        vertical: boolean;
+        disabled: boolean;
+        buttonStyle: import("./interface").RadioGroupButtonStyle;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").RadioGroupProps> & Readonly<{
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        "onUpdate:value"?: ((value: any) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        block: boolean;
+        vertical: boolean;
+        disabled: boolean;
+        buttonStyle: import("./interface").RadioGroupButtonStyle;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").RadioGroupProps> & Readonly<{
+    onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+    "onUpdate:value"?: ((value: any) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (event: import("./interface").RadioChangeEvent) => any;
+    "update:value": (value: any) => any;
+}, string, {
+    block: boolean;
+    vertical: boolean;
+    disabled: boolean;
+    buttonStyle: import("./interface").RadioGroupButtonStyle;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").RadioGroupSlots;
+}), object>;
+export declare const RadioButton: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").RadioButtonProps> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    }>, {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        readonly input: HTMLInputElement | null;
+        readonly nativeElement: HTMLElement | null;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        change: (event: import("./interface").RadioChangeEvent) => any;
+        click: (event: MouseEvent) => any;
+        focus: (event: FocusEvent) => any;
+        "update:checked": (checked: boolean) => any;
+    }, import("vue").PublicProps, {
+        disabled: boolean;
+        checked: boolean;
+        defaultChecked: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").RadioButtonProps> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    }>, {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        readonly input: HTMLInputElement | null;
+        readonly nativeElement: HTMLElement | null;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        checked: boolean;
+        defaultChecked: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").RadioButtonProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+}>, {
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+    readonly input: HTMLInputElement | null;
+    readonly nativeElement: HTMLElement | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (event: import("./interface").RadioChangeEvent) => any;
+    click: (event: MouseEvent) => any;
+    focus: (event: FocusEvent) => any;
+    "update:checked": (checked: boolean) => any;
+}, string, {
+    disabled: boolean;
+    checked: boolean;
+    defaultChecked: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").RadioButtonSlots;
+}), object>;
+declare const Radio: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").RadioProps> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    }>, {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        readonly input: HTMLInputElement | null;
+        readonly nativeElement: HTMLElement | null;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        change: (event: import("./interface").RadioChangeEvent) => any;
+        click: (event: MouseEvent) => any;
+        focus: (event: FocusEvent) => any;
+        "update:checked": (checked: boolean) => any;
+    }, import("vue").PublicProps, {
+        block: boolean;
+        icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").RadioIconContext) => import("vue").VNodeChild) | null;
+        disabled: boolean;
+        checked: boolean;
+        defaultChecked: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").RadioProps> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    }>, {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        readonly input: HTMLInputElement | null;
+        readonly nativeElement: HTMLElement | null;
+    }, {}, {}, {}, {
+        block: boolean;
+        icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").RadioIconContext) => import("vue").VNodeChild) | null;
+        disabled: boolean;
+        checked: boolean;
+        defaultChecked: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").RadioProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+}>, {
+    focus: () => void | undefined;
+    blur: () => void | undefined;
+    readonly input: HTMLInputElement | null;
+    readonly nativeElement: HTMLElement | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (event: import("./interface").RadioChangeEvent) => any;
+    click: (event: MouseEvent) => any;
+    focus: (event: FocusEvent) => any;
+    "update:checked": (checked: boolean) => any;
+}, string, {
+    block: boolean;
+    icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").RadioIconContext) => import("vue").VNodeChild) | null;
+    disabled: boolean;
+    checked: boolean;
+    defaultChecked: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").RadioSlots;
+}), {
+    Group: import("../_util/withInstall").WithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").RadioGroupProps> & Readonly<{
+            onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+            "onUpdate:value"?: ((value: any) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            change: (event: import("./interface").RadioChangeEvent) => any;
+            "update:value": (value: any) => any;
+        }, import("vue").PublicProps, {
+            block: boolean;
+            vertical: boolean;
+            disabled: boolean;
+            buttonStyle: import("./interface").RadioGroupButtonStyle;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./interface").RadioGroupProps> & Readonly<{
+            onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+            "onUpdate:value"?: ((value: any) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            block: boolean;
+            vertical: boolean;
+            disabled: boolean;
+            buttonStyle: import("./interface").RadioGroupButtonStyle;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./interface").RadioGroupProps> & Readonly<{
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        "onUpdate:value"?: ((value: any) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (event: import("./interface").RadioChangeEvent) => any;
+        "update:value": (value: any) => any;
+    }, string, {
+        block: boolean;
+        vertical: boolean;
+        disabled: boolean;
+        buttonStyle: import("./interface").RadioGroupButtonStyle;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: import("./interface").RadioGroupSlots;
+    }), object>;
+    Button: import("../_util/withInstall").WithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").RadioButtonProps> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+            onClick?: ((event: MouseEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+        }>, {
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            readonly input: HTMLInputElement | null;
+            readonly nativeElement: HTMLElement | null;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            change: (event: import("./interface").RadioChangeEvent) => any;
+            click: (event: MouseEvent) => any;
+            focus: (event: FocusEvent) => any;
+            "update:checked": (checked: boolean) => any;
+        }, import("vue").PublicProps, {
+            disabled: boolean;
+            checked: boolean;
+            defaultChecked: boolean;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./interface").RadioButtonProps> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+            onClick?: ((event: MouseEvent) => any) | undefined;
+            onFocus?: ((event: FocusEvent) => any) | undefined;
+            "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+        }>, {
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            readonly input: HTMLInputElement | null;
+            readonly nativeElement: HTMLElement | null;
+        }, {}, {}, {}, {
+            disabled: boolean;
+            checked: boolean;
+            defaultChecked: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./interface").RadioButtonProps> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: import("./interface").RadioChangeEvent) => any) | undefined;
+        onClick?: ((event: MouseEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:checked"?: ((checked: boolean) => any) | undefined;
+    }>, {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        readonly input: HTMLInputElement | null;
+        readonly nativeElement: HTMLElement | null;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        blur: (event: FocusEvent) => any;
+        change: (event: import("./interface").RadioChangeEvent) => any;
+        click: (event: MouseEvent) => any;
+        focus: (event: FocusEvent) => any;
+        "update:checked": (checked: boolean) => any;
+    }, string, {
+        disabled: boolean;
+        checked: boolean;
+        defaultChecked: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: import("./interface").RadioButtonSlots;
+    }), object>;
+}>;
+export default Radio;

package/dist/radio/index.js

@@ -0,0 +1,12 @@
+import { withInstall } from "../_util/withInstall.js";
+import Radio_default from "./Radio.js";
+import RadioButton_default from "./RadioButton.js";
+import RadioGroup_default from "./RadioGroup.js";
+// src/radio/index.ts
+var RadioGroup = withInstall(RadioGroup_default, "AmRadioGroup");
+var RadioButton = withInstall(RadioButton_default, "AmRadioButton");
+var Radio = withInstall(Radio_default, "AmRadio", {
+	Group: RadioGroup,
+	Button: RadioButton
+});
+export { RadioButton, RadioGroup, Radio as default };

package/dist/radio/interface.d.ts

@@ -0,0 +1,142 @@
+import type { CSSProperties } from 'vue';
+import type { RenderNodeFn, SizeType, VueNode } from '../_util/type';
+export type RadioGroupButtonStyle = 'outline' | 'solid';
+export type RadioGroupOptionType = 'default' | 'button';
+export type RadioGroupOrientation = 'horizontal' | 'vertical';
+export interface RadioSemanticClassNames {
+    root?: string;
+    icon?: string;
+    label?: string;
+}
+export interface RadioSemanticStyles {
+    root?: CSSProperties;
+    icon?: CSSProperties;
+    label?: CSSProperties;
+}
+export interface RadioIconContext {
+    checked: boolean;
+    disabled: boolean;
+}
+export interface RadioProps {
+    /** Whether the radio is checked (`v-model:checked`) */
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    /** Value used by `Radio.Group` */
+    value?: any;
+    name?: string;
+    id?: string;
+    title?: string;
+    tabIndex?: number;
+    autoFocus?: boolean;
+    required?: boolean;
+    /** Render as a button, `Radio.Button` is a shortcut of `optionType="button"` */
+    optionType?: RadioGroupOptionType;
+    /** Mobile: full-width row, label at the start and the radio at the end */
+    block?: boolean;
+    /** Mobile: custom icon, the same-named slot wins */
+    icon?: RenderNodeFn<RadioIconContext>;
+    rootClass?: string;
+    classes?: RadioSemanticClassNames;
+    styles?: RadioSemanticStyles;
+}
+export interface RadioButtonProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    value?: any;
+    name?: string;
+    id?: string;
+    title?: string;
+    tabIndex?: number;
+    autoFocus?: boolean;
+    required?: boolean;
+    rootClass?: string;
+    classes?: RadioSemanticClassNames;
+    styles?: RadioSemanticStyles;
+}
+export interface RadioChangeEventTarget extends RadioProps {
+    checked: boolean;
+}
+export interface RadioChangeEvent {
+    target: RadioChangeEventTarget;
+    stopPropagation: () => void;
+    preventDefault: () => void;
+    nativeEvent: Event;
+}
+export interface RadioEmits {
+    'change': [event: RadioChangeEvent];
+    'update:checked': [checked: boolean];
+    'click': [event: MouseEvent];
+    'focus': [event: FocusEvent];
+    'blur': [event: FocusEvent];
+}
+export interface RadioSlots {
+    default?: () => any;
+    icon?: (ctx: RadioIconContext) => any;
+}
+export interface RadioButtonSlots {
+    default?: () => any;
+}
+export interface RadioExpose {
+    focus: () => void;
+    blur: () => void;
+    input: HTMLInputElement | null;
+    nativeElement: HTMLElement | null;
+}
+export interface RadioOptionType {
+    label: VueNode;
+    value: any;
+    disabled?: boolean;
+    title?: string;
+    id?: string;
+    required?: boolean;
+    class?: string;
+    style?: CSSProperties;
+}
+export interface RadioGroupSemanticClassNames {
+    root?: string;
+    item?: string;
+    itemIcon?: string;
+    itemLabel?: string;
+}
+export interface RadioGroupSemanticStyles {
+    root?: CSSProperties;
+    item?: CSSProperties;
+    itemIcon?: CSSProperties;
+    itemLabel?: CSSProperties;
+}
+export interface RadioGroupLabelRenderParams {
+    item: RadioOptionType;
+    index: number;
+}
+export interface RadioGroupProps {
+    /** Selected value (`v-model:value`) */
+    value?: any;
+    defaultValue?: any;
+    options?: (RadioOptionType | string | number)[];
+    optionType?: RadioGroupOptionType;
+    buttonStyle?: RadioGroupButtonStyle;
+    /** Size of button style radios */
+    size?: SizeType;
+    disabled?: boolean;
+    name?: string;
+    id?: string;
+    /** Fit the width of the parent; for `optionType="default"` every radio becomes a list row */
+    block?: boolean;
+    vertical?: boolean;
+    orientation?: RadioGroupOrientation;
+    labelRender?: (params: RadioGroupLabelRenderParams) => any;
+    rootClass?: string;
+    classes?: RadioGroupSemanticClassNames;
+    styles?: RadioGroupSemanticStyles;
+}
+export interface RadioGroupEmits {
+    'change': [event: RadioChangeEvent];
+    'update:value': [value: any];
+}
+export interface RadioGroupSlots {
+    default?: () => any;
+    labelRender?: (params: RadioGroupLabelRenderParams) => any;
+    icon?: (ctx: RadioIconContext) => any;
+}