@vunk/form 0.0.1-alpha.3 → 0.0.1-alpha.30

package/components/input-number/src/ctx.d.ts

@@ -1,4 +1,12 @@
 export declare const props: {
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    unit: {
+        type: StringConstructor;
+        default: string;
+    };
     id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
     step: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
     stepStrictly: BooleanConstructor;
@@ -9,7 +17,7 @@ export declare const props: {
     size: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     controls: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -21,7 +29,7 @@ export declare const props: {
     precision: {
         readonly type: import("vue").PropType<number>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -30,20 +38,20 @@ export declare const props: {
     prop: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     rules: {
-        readonly type: import("vue").PropType<unknown>;
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     error: StringConstructor;
     validateStatus: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     for: StringConstructor;
@@ -55,17 +63,21 @@ export declare const props: {
     };
     formItemSlots: {
         type: import("vue").PropType<import("../../form-item/src/types").FormItemSlots>;
-        default: any;
+        default: undefined;
     };
     elRef: {
         type: import("vue").PropType<any>;
         required: boolean;
     };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 };
 export declare const emits: {
-    change: (prev: number, cur: number) => boolean;
+    change: (prev: number | undefined, cur: number | undefined) => boolean;
     blur: (e: FocusEvent) => boolean;
     focus: (e: FocusEvent) => boolean;
-    input: (val: number) => boolean;
-    "update:modelValue": (val: number) => boolean;
+    input: (val: number | null | undefined) => boolean;
+    "update:modelValue": (val: number | undefined) => boolean;
 };

package/components/input-number/src/ctx.js

@@ -2,6 +2,8 @@ import { _VkfFormItemCtx } from '@vunk/form/components/form-item';
 import { inputNumberProps, inputNumberEmits } from 'element-plus';
 
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -17,7 +19,17 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const props = __spreadValues(__spreadValues({}, _VkfFormItemCtx.props), inputNumberProps);
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), inputNumberProps), {
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  unit: {
+    type: String,
+    default: ""
+  }
+});
 const emits = __spreadValues({}, inputNumberEmits);
 
 export { emits, props };

package/components/input-number/src/index.vue.d.ts

@@ -1,4 +1,12 @@
 declare const _default: import("vue").DefineComponent<{
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    unit: {
+        type: StringConstructor;
+        default: string;
+    };
     id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
     step: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
     stepStrictly: BooleanConstructor;
@@ -9,7 +17,7 @@ declare const _default: import("vue").DefineComponent<{
     size: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     controls: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -21,7 +29,7 @@ declare const _default: import("vue").DefineComponent<{
     precision: {
         readonly type: import("vue").PropType<number>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -30,20 +38,20 @@ declare const _default: import("vue").DefineComponent<{
     prop: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     rules: {
-        readonly type: import("vue").PropType<unknown>;
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     error: StringConstructor;
     validateStatus: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     for: StringConstructor;
@@ -55,29 +63,74 @@ declare const _default: import("vue").DefineComponent<{
     };
     formItemSlots: {
         type: import("vue").PropType<import("../../form-item/src/types").FormItemSlots>;
-        default: any;
+        default: undefined;
     };
     elRef: {
         type: import("vue").PropType<any>;
         required: boolean;
     };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }, {
-    formItemBindProps: import("vue").ComputedRef<{}>;
-    iBindProps: import("vue").ComputedRef<{}>;
+    formItemBindProps: import("vue").ComputedRef<{
+        required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+        label: string | undefined;
+        labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        prop: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown> | undefined;
+        rules: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown> | undefined;
+        error: string | undefined;
+        validateStatus: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown> | undefined;
+        for: string | undefined;
+        inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+        showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        formItemSize: "default" | "small" | "large";
+        formItemSlots: import("../../form-item/src/types").FormItemSlots | undefined;
+        elRef: any;
+        inline: boolean;
+        readonly: boolean | undefined;
+    }>;
+    iBindProps: import("vue").ComputedRef<{
+        label: string | undefined;
+        size: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
+        name: string | undefined;
+        id: string | undefined;
+        validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        placeholder: string | undefined;
+        modelValue: number | undefined;
+        step: number;
+        stepStrictly: boolean;
+        max: number;
+        min: number;
+        controls: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        controlsPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "right", unknown>;
+        valueOnClear: any;
+        precision: number | undefined;
+    }>;
     iOnEmits: {
-        "update:modelValue": ((event: "update:modelValue", val: number) => void) & ((event: "change", prev: number, cur: number) => void) & ((event: "focus", e: FocusEvent) => void) & ((event: "blur", e: FocusEvent) => void) & ((event: "input", val: number) => void);
-        change: ((event: "update:modelValue", val: number) => void) & ((event: "change", prev: number, cur: number) => void) & ((event: "focus", e: FocusEvent) => void) & ((event: "blur", e: FocusEvent) => void) & ((event: "input", val: number) => void);
-        focus: ((event: "update:modelValue", val: number) => void) & ((event: "change", prev: number, cur: number) => void) & ((event: "focus", e: FocusEvent) => void) & ((event: "blur", e: FocusEvent) => void) & ((event: "input", val: number) => void);
-        blur: ((event: "update:modelValue", val: number) => void) & ((event: "change", prev: number, cur: number) => void) & ((event: "focus", e: FocusEvent) => void) & ((event: "blur", e: FocusEvent) => void) & ((event: "input", val: number) => void);
-        input: ((event: "update:modelValue", val: number) => void) & ((event: "change", prev: number, cur: number) => void) & ((event: "focus", e: FocusEvent) => void) & ((event: "blur", e: FocusEvent) => void) & ((event: "input", val: number) => void);
+        input: (val: number | undefined) => void;
+        blur: (val: number | undefined) => void;
+        change: (val: number | undefined) => void;
+        focus: (val: number | undefined) => void;
+        "update:modelValue": (val: number | undefined) => void;
     };
+    readonly: import("vue").ComputedRef<boolean>;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    change: (prev: number, cur: number) => boolean;
+    change: (prev: number | undefined, cur: number | undefined) => boolean;
     blur: (e: FocusEvent) => boolean;
     focus: (e: FocusEvent) => boolean;
-    input: (val: number) => boolean;
-    "update:modelValue": (val: number) => boolean;
+    input: (val: number | null | undefined) => boolean;
+    "update:modelValue": (val: number | undefined) => boolean;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    unit: {
+        type: StringConstructor;
+        default: string;
+    };
     id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
     step: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
     stepStrictly: BooleanConstructor;
@@ -88,7 +141,7 @@ declare const _default: import("vue").DefineComponent<{
     size: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     controls: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -100,7 +153,7 @@ declare const _default: import("vue").DefineComponent<{
     precision: {
         readonly type: import("vue").PropType<number>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
@@ -109,20 +162,20 @@ declare const _default: import("vue").DefineComponent<{
     prop: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     rules: {
-        readonly type: import("vue").PropType<unknown>;
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     error: StringConstructor;
     validateStatus: {
         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
         readonly required: false;
-        readonly validator: (val: unknown) => boolean;
+        readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     for: StringConstructor;
@@ -134,18 +187,22 @@ declare const _default: import("vue").DefineComponent<{
     };
     formItemSlots: {
         type: import("vue").PropType<import("../../form-item/src/types").FormItemSlots>;
-        default: any;
+        default: undefined;
     };
     elRef: {
         type: import("vue").PropType<any>;
         required: boolean;
     };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 }>> & {
-    "onUpdate:modelValue"?: (val: number) => any;
-    onChange?: (prev: number, cur: number) => any;
-    onFocus?: (e: FocusEvent) => any;
-    onBlur?: (e: FocusEvent) => any;
-    onInput?: (val: number) => any;
+    "onUpdate:modelValue"?: ((val: number | undefined) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+    onChange?: ((prev: number | undefined, cur: number | undefined) => any) | undefined;
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+    onInput?: ((val: number | null | undefined) => any) | undefined;
 }, {
     required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
@@ -153,15 +210,18 @@ declare const _default: import("vue").DefineComponent<{
     showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     formItemSize: "default" | "small" | "large";
     formItemSlots: import("../../form-item/src/types").FormItemSlots;
-    validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    id: string;
+    inline: boolean;
+    readonly: boolean;
     disabled: boolean;
+    id: string;
+    validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     step: number;
     stepStrictly: boolean;
     max: number;
     min: number;
     controls: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
     controlsPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "right", unknown>;
-    valueOnClear: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor, null], unknown, unknown>;
+    valueOnClear: any;
+    unit: string;
 }>;
 export default _default;

package/components/radio/index.css

@@ -0,0 +1,29 @@
+
+.el-radio-group.is-readonly,
+.el-radio-group.is-readonly .el-radio-button{
+  --el-readonly-cursor: auto;
+  --el-disabled-bg-color: initial;
+  --el-disabled-text-color: initial;
+  --el-radio-button-disabled-checked-fill: var(--el-radio-button-checked-bg-color);
+}
+
+.el-radio-group.is-readonly .is-active .el-radio-button__original-radio:disabled+.el-radio-button__inner{
+  color: var(--el-radio-button-checked-text-color);
+}
+.el-radio-group.is-readonly .el-radio-button__original-radio:disabled+.el-radio-button__inner {
+  cursor: var(--el-readonly-cursor);
+}
+
+.el-radio-group.is-readonly  .el-radio__input.is-checked+.el-radio__label{
+ color: var(--el-color-primary);
+}
+.el-radio-group.is-readonly .el-radio__input.is-checked .el-radio__inner {
+  border-color: var(--el-color-primary);
+  background: var(--el-color-primary);
+
+}
+.el-radio-group.is-readonly .el-radio__input .el-radio__inner,
+.el-radio-group.is-readonly .el-radio__input.is-disabled+span.el-radio__label {
+ cursor: var(--el-readonly-cursor);
+}
+ 

package/components/radio/index.d.ts

@@ -0,0 +1,4 @@
+import VkfRadio from './src/index.vue';
+export * as __VkfRadio from './src/types';
+export { VkfRadio, };
+export default VkfRadio;

package/components/radio/index.js

@@ -0,0 +1,121 @@
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
+import { radioGroupProps, radioGroupEmits, ElRadio, ElRadioGroup, ElRadioButton } from 'element-plus';
+import { defineComponent, computed, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, toHandlers, createElementBlock, Fragment, renderList, resolveDynamicComponent, createTextVNode, toDisplayString } from 'vue';
+import { createRadioGroupBindProps, createRadioGroupOnEmits } from '@vunk/form/shared/element-plus';
+import { pickObject } from '@vunk/core/shared/utils-object';
+import { useComputedReadonly } from '@vunk/form/composables';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), radioGroupProps), {
+  options: {
+    type: Array,
+    default: () => []
+  },
+  type: {
+    type: String,
+    default: "default"
+  },
+  modelValue: {
+    type: [String, Number]
+  },
+  defaultModelValue: null
+});
+const emits = __spreadValues({}, radioGroupEmits);
+
+var script = defineComponent({
+  name: "VkfRadio",
+  components: {
+    VkfFormItem,
+    ElRadio,
+    ElRadioGroup,
+    ElRadioButton
+  },
+  emits,
+  props,
+  setup(props2, { emit }) {
+    const formItemBindProps = _VkfFormItemCtx.createBindProps(props2);
+    const coreBindProps = createRadioGroupBindProps(props2, ["disabled"]);
+    const coreOnEmits = createRadioGroupOnEmits(emit);
+    const options = computed(() => {
+      return props2.options.filter((item) => item.value !== void 0 && item.value !== null);
+    });
+    const readonly = useComputedReadonly(props2);
+    !props2.modelValue && props2.defaultModelValue && emit("update:modelValue", props2.defaultModelValue);
+    return {
+      formItemBindProps,
+      coreBindProps,
+      coreOnEmits,
+      options,
+      pickObject,
+      readonly
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElRadioGroup = resolveComponent("ElRadioGroup");
+  const _component_VkfFormItem = resolveComponent("VkfFormItem");
+  return openBlock(), createBlock(_component_VkfFormItem, normalizeProps(guardReactiveProps(_ctx.formItemBindProps)), {
+    default: withCtx(() => [
+      createVNode(_component_ElRadioGroup, mergeProps({
+        class: {
+          "is-readonly": _ctx.readonly
+        }
+      }, _ctx.coreBindProps, toHandlers(_ctx.coreOnEmits), {
+        disabled: _ctx.readonly || _ctx.disabled
+      }), {
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.options, (item) => {
+            return openBlock(), createBlock(resolveDynamicComponent(_ctx.type === "button" ? "ElRadioButton" : "ElRadio"), mergeProps({
+              key: item.value,
+              label: item.value
+            }, _ctx.pickObject(item, {
+              excludes: ["label", "value"]
+            })), {
+              default: withCtx(() => {
+                var _a;
+                return [
+                  createTextVNode(toDisplayString((_a = item.label) != null ? _a : item.value), 1)
+                ];
+              }),
+              _: 2
+            }, 1040, ["label"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 16, ["class", "disabled"])
+    ]),
+    _: 1
+  }, 16);
+}
+
+script.render = render;
+script.__file = "radio/src/index.vue";
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+script.install = (app) => {
+  app.component(script.name, script);
+};
+
+export { script as VkfRadio, types as __VkfRadio, script as default };

package/components/radio/src/ctx.d.ts

@@ -0,0 +1,77 @@
+import { RadioProps } from '@vunk/form/shared/types/form';
+import { PropType } from 'vue';
+export declare const props: {
+    options: {
+        type: PropType<RadioProps[]>;
+        default: () => never[];
+    };
+    type: {
+        type: PropType<"default" | "button">;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<string | number>;
+    };
+    defaultModelValue: null;
+    id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    size: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    fill: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    textColor: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    name: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    formItemSize: {
+        type: PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: PropType<import("../../form-item/src/types").FormItemSlots>;
+        default: undefined;
+    };
+    elRef: {
+        type: PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+export declare const emits: {
+    "update:modelValue": (val: string | number | boolean) => boolean;
+    change: (val: string | number | boolean) => boolean;
+};

package/components/radio/src/ctx.js

@@ -0,0 +1,39 @@
+import { _VkfFormItemCtx } from '@vunk/form/components/form-item';
+import { radioGroupProps, radioGroupEmits } from 'element-plus';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const props = __spreadProps(__spreadValues(__spreadValues({}, _VkfFormItemCtx.props), radioGroupProps), {
+  options: {
+    type: Array,
+    default: () => []
+  },
+  type: {
+    type: String,
+    default: "default"
+  },
+  modelValue: {
+    type: [String, Number]
+  },
+  defaultModelValue: null
+});
+const emits = __spreadValues({}, radioGroupEmits);
+
+export { emits, props };