yc-design-vue 1.0.1

package/es/Progress/ProgressLine.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./ProgressLine.vue2.js";
+/* empty css                  */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const ProgressLine = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ccea0502"]]);
+export {
+  ProgressLine as default
+};

package/es/Progress/ProgressLine.vue2.js

@@ -0,0 +1,100 @@
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, unref, createElementVNode, createCommentVNode, normalizeStyle, renderSlot, createBlock, toDisplayString, resolveDynamicComponent } from "vue";
+import { TYPE_ICON_MAP, TYPE_ICON_COLOR_MAP } from "../_shared/constants/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { valueToPx } from "../_shared/utils/fn.js";
+import { isObject } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+const _hoisted_1 = ["aria-valuenow"];
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-progress-line-text"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ProgressLine",
+  props: {
+    size: {},
+    percent: {},
+    status: {},
+    showText: { type: Boolean },
+    text: {},
+    width: {},
+    strokeWidth: {},
+    color: {},
+    trackColor: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      width,
+      trackColor,
+      color,
+      percent,
+      size,
+      strokeWidth: _strokeWidth
+    } = toRefs(props);
+    const strokeWidth = computed(() => {
+      const map = {
+        small: 3,
+        medium: 4,
+        large: 8
+      };
+      return _strokeWidth.value ?? map[size.value];
+    });
+    const style = computed(() => ({
+      width: valueToPx(width.value),
+      height: valueToPx(strokeWidth.value),
+      backgroundColor: trackColor.value
+    }));
+    const barStyle = computed(() => {
+      return {
+        width: `${percent.value * 100}%`,
+        ...getBackground(color.value)
+      };
+    });
+    const getBackground = (color2) => {
+      if (isObject(color2)) {
+        const val = Object.keys(color2).map((key) => `${color2[key]} ${key}`).join(",");
+        return {
+          backgroundImage: `linear-gradient(to right, ${val})`
+        };
+      }
+      return {
+        backgroundColor: color2
+      };
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        role: "progressbar",
+        "aria-valuemin": "0",
+        "aria-valuemax": "100",
+        "aria-valuenow": unref(percent),
+        class: "yc-progress-line-wrapper"
+      }, [
+        createElementVNode("div", {
+          class: "yc-progress-line",
+          style: normalizeStyle(style.value)
+        }, [
+          createElementVNode("div", {
+            class: "yc-progress-line-bar",
+            style: normalizeStyle(barStyle.value)
+          }, null, 4)
+        ], 4),
+        _ctx.showText ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          renderSlot(_ctx.$slots, "text", { percent: unref(percent) }, () => [
+            createElementVNode("span", null, toDisplayString(_ctx.text), 1),
+            _ctx.status === "danger" ? (openBlock(), createBlock(resolveDynamicComponent(unref(TYPE_ICON_MAP).warning), {
+              key: 0,
+              color: unref(TYPE_ICON_COLOR_MAP).error
+            }, null, 8, ["color"])) : createCommentVNode("", true)
+          ], true)
+        ])) : createCommentVNode("", true)
+      ], 8, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Progress/ProgressSteps.vue.d.ts

@@ -0,0 +1,32 @@
+import { ProgressColor } from './type';
+import { Size } from '../_shared/type';
+type __VLS_Props = {
+    steps: number;
+    percent: number;
+    size: Size;
+    text: string;
+    showText: boolean;
+    color?: ProgressColor;
+    trackColor?: string;
+    strokeWidth?: number;
+    status?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        text?(_: {
+            percent: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Progress/ProgressSteps.vue.js

@@ -0,0 +1,82 @@
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, unref, createElementVNode, createCommentVNode, normalizeStyle, Fragment, renderList, normalizeClass, renderSlot, createTextVNode, createBlock, toDisplayString, resolveDynamicComponent } from "vue";
+import { TYPE_ICON_MAP, TYPE_ICON_COLOR_MAP } from "../_shared/constants/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { valueToPx } from "../_shared/utils/fn.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+const _hoisted_1 = ["aria-valuenow"];
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-progress-steps-text"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ProgressSteps",
+  props: {
+    steps: {},
+    percent: {},
+    size: {},
+    text: {},
+    showText: { type: Boolean },
+    color: {},
+    trackColor: {},
+    strokeWidth: {},
+    status: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { steps, percent, size, strokeWidth: _strokeWidth } = toRefs(props);
+    const strokeWidth = computed(() => {
+      return _strokeWidth.value ?? (size.value == "small" ? 8 : 4);
+    });
+    const stepList = computed(() => {
+      return Array(steps.value).fill(0).map((_, i) => {
+        {
+          return percent.value > 0 && percent.value > 1 / steps.value * i;
+        }
+      });
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        role: "progressbar",
+        "aria-valuemin": "0",
+        "aria-valuemax": "100",
+        "aria-valuenow": unref(percent),
+        class: "yc-progress-steps-wrapper"
+      }, [
+        createElementVNode("div", {
+          class: "yc-progress-steps",
+          style: normalizeStyle({ height: unref(valueToPx)(strokeWidth.value) })
+        }, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(stepList.value, (active, i) => {
+            return openBlock(), createElementBlock("div", {
+              key: i,
+              class: normalizeClass([
+                "yc-progress-steps-item",
+                {
+                  "yc-progress-steps-item-active": active
+                }
+              ]),
+              style: normalizeStyle({
+                backgroundColor: active ? _ctx.color : _ctx.trackColor
+              })
+            }, null, 6);
+          }), 128))
+        ], 4),
+        _ctx.showText ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          renderSlot(_ctx.$slots, "text", { percent: unref(percent) }, () => [
+            createTextVNode(toDisplayString(_ctx.text) + " ", 1),
+            _ctx.status === "danger" ? (openBlock(), createBlock(resolveDynamicComponent(unref(TYPE_ICON_MAP).danger), {
+              key: 0,
+              color: unref(TYPE_ICON_COLOR_MAP).danger
+            }, null, 8, ["color"])) : createCommentVNode("", true)
+          ])
+        ])) : createCommentVNode("", true)
+      ], 8, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Progress/ProgressSteps.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./ProgressSteps.vue.js";
+/* empty css                   */
+export {
+  _sfc_main as default
+};

package/es/Progress/index.d.ts

@@ -0,0 +1,61 @@
+import { App } from 'vue';
+import { default as _Progress } from './Progress.vue';
+export type ProgressInstance = InstanceType<typeof _Progress>;
+export * from './type';
+declare const Progress: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').ProgressProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: import('..').Size;
+        type: import('./type').ProgressType;
+        animation: boolean;
+        status: import('./type').ProgressStatus;
+        showText: boolean;
+        percent: number;
+        steps: number;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').ProgressProps> & Readonly<{}>, {}, {}, {}, {}, {
+        size: import('..').Size;
+        type: import('./type').ProgressType;
+        animation: boolean;
+        status: import('./type').ProgressStatus;
+        showText: boolean;
+        percent: number;
+        steps: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').ProgressProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: import('..').Size;
+    type: import('./type').ProgressType;
+    animation: boolean;
+    status: import('./type').ProgressStatus;
+    showText: boolean;
+    percent: number;
+    steps: number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        text?(_: {
+            percent: number;
+        }): any;
+        text?(_: {
+            percent: number;
+        }): any;
+        text?(_: {
+            percent: number;
+        }): any;
+    };
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcProgress: typeof Progress;
+    }
+}
+export default Progress;

package/es/Progress/index.js

@@ -0,0 +1,9 @@
+import _Progress from "./Progress.vue.js";
+const Progress = Object.assign(_Progress, {
+  install: (app) => {
+    app.component("Yc" + _Progress.name, _Progress);
+  }
+});
+export {
+  Progress as default
+};

package/es/Progress/type.d.ts

@@ -0,0 +1,17 @@
+import { Size } from '../_shared/type';
+export interface ProgressProps {
+    type?: ProgressType;
+    size?: Size;
+    percent?: number;
+    steps?: number;
+    animation?: boolean;
+    strokeWidth?: number;
+    width?: number;
+    color?: ProgressColor;
+    trackColor?: string;
+    showText?: boolean;
+    status?: ProgressStatus;
+}
+export type ProgressType = 'line' | 'circle';
+export type ProgressColor = string | Record<string, string>;
+export type ProgressStatus = 'normal' | 'success' | 'warning' | 'danger';

package/es/Radio/Radio.vue.d.ts

@@ -0,0 +1,28 @@
+import { RadioProps, RadioSlots, RadioValue } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<RadioSlots> & RadioSlots;
+    refs: {};
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<RadioProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: RadioValue, ev: Event) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<RadioProps> & Readonly<{
+    onChange?: ((value: RadioValue, ev: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    value: RadioValue;
+    type: import('./type').RadioType;
+    defaultChecked: boolean;
+    modelValue: RadioValue;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Radio/Radio.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./Radio.vue2.js";
+/* empty css           */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const _Radio = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-05121562"]]);
+export {
+  _Radio as default
+};

package/es/Radio/Radio.vue2.js

@@ -0,0 +1,123 @@
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, renderSlot, Fragment, createVNode, createCommentVNode, withCtx } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useControlValue from "../_shared/utils/control.js";
+import useContext from "./hooks/useContext.js";
+import IconButton from "../_shared/components/IconButton.vue.js";
+/* empty css                                         */
+const _hoisted_1 = ["value", "checked", "disabled"];
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-radio-label text-ellipsis"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "yc-radio-button-content"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Radio"
+  },
+  __name: "Radio",
+  props: {
+    modelValue: { type: [String, Number, Boolean], default: void 0 },
+    defaultChecked: { type: Boolean, default: false },
+    value: { type: [String, Number, Boolean], default: true },
+    type: { default: void 0 },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      modelValue,
+      defaultChecked,
+      value: radioValue,
+      disabled,
+      type
+    } = toRefs(props);
+    const {
+      computedValue: _computedValue,
+      disabled: injectDisabled,
+      type: injectType,
+      size,
+      hasGroup,
+      emits: _emits
+    } = useContext().inject();
+    const computedValue = useControlValue(
+      modelValue,
+      defaultChecked.value,
+      (val) => {
+        emits("update:modelValue", val);
+      }
+    );
+    const checked = computed(() => {
+      return hasGroup.value ? _computedValue.value == radioValue.value : computedValue.value;
+    });
+    const computedDisabled = computed(() => {
+      return injectDisabled.value || disabled.value;
+    });
+    const computedType = computed(() => {
+      return type.value ?? injectType.value;
+    });
+    const handleChange = (e) => {
+      if (computedDisabled.value) return;
+      if (hasGroup.value) {
+        _computedValue.value = radioValue.value;
+      } else {
+        computedValue.value = radioValue.value;
+        emits("change", radioValue.value, e);
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        class: normalizeClass([
+          `yc-radio-button-size-${unref(size)}`,
+          `yc-radio${computedType.value == "radio" ? "" : "-button"}`,
+          `yc-radio-${checked.value ? "checked" : "unchecked"}`,
+          {
+            "yc-radio-disabled": computedDisabled.value
+          }
+        ]),
+        onClick: handleChange
+      }, [
+        createElementVNode("input", {
+          type: "radio",
+          class: "yc-radio-target",
+          value: _ctx.value,
+          checked: checked.value,
+          disabled: computedDisabled.value
+        }, null, 8, _hoisted_1),
+        renderSlot(_ctx.$slots, "radio", {
+          checked: checked.value,
+          disabled: computedDisabled.value
+        }, () => [
+          computedType.value == "radio" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+            createVNode(unref(IconButton), {
+              "hover-size": 24,
+              "hover-color": checked.value || computedDisabled.value ? "transparent" : "rgb(242, 243, 245)"
+            }, {
+              default: withCtx(() => _cache[0] || (_cache[0] = [
+                createElementVNode("span", { class: "yc-radio-icon" }, null, -1)
+              ])),
+              _: 1,
+              __: [0]
+            }, 8, ["hover-color"]),
+            _ctx.$slots.default ? (openBlock(), createElementBlock("span", _hoisted_2, [
+              renderSlot(_ctx.$slots, "default", {}, void 0, true)
+            ])) : createCommentVNode("", true)
+          ], 64)) : (openBlock(), createElementBlock("span", _hoisted_3, [
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ]))
+        ], true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Radio/RadioGroup.vue.d.ts

@@ -0,0 +1,30 @@
+import { RadioGroupProps, RadioGroupSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<RadioGroupSlots> & RadioGroupSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<RadioGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('./type').RadioValue) => any;
+    "update:modelValue": (value: import('./type').RadioValue) => any;
+}, string, import('vue').PublicProps, Readonly<RadioGroupProps> & Readonly<{
+    onChange?: ((value: import('./type').RadioValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./type').RadioValue) => any) | undefined;
+}>, {
+    size: import('..').Size;
+    disabled: boolean;
+    type: import('./type').RadioType;
+    direction: import('..').Direction;
+    modelValue: import('./type').RadioValue;
+    defaultValue: import('./type').RadioValue;
+    options: import('./type').RadioOption[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Radio/RadioGroup.vue.js

@@ -0,0 +1,59 @@
+import { defineComponent, createElementBlock, openBlock, normalizeClass, renderSlot, Fragment, renderList, unref, createBlock, createSlots, withCtx, createTextVNode, toDisplayString, mergeProps } from "vue";
+import useContext from "./hooks/useContext.js";
+import _Radio from "./Radio.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "RadioGroup"
+  },
+  __name: "RadioGroup",
+  props: {
+    modelValue: { type: [String, Number, Boolean], default: void 0 },
+    defaultValue: { type: [String, Number, Boolean], default: "" },
+    size: { default: void 0 },
+    type: { default: "radio" },
+    options: { default: () => [] },
+    direction: { default: "horizontal" },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { options } = useContext().provide(props, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          _ctx.type == "radio" ? "yc-radio-group" : "yc-radio-button-group",
+          _ctx.type == "radio" ? `yc-radio-group-direction-${_ctx.direction}` : `yc-radio-button-group-size-${_ctx.size}`
+        ])
+      }, [
+        renderSlot(_ctx.$slots, "default"),
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(options), (item, index) => {
+          return openBlock(), createBlock(_Radio, {
+            key: index,
+            value: item.value,
+            disabled: item.disabled
+          }, createSlots({
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "label", { data: item }, () => [
+                createTextVNode(toDisplayString(item.label), 1)
+              ])
+            ]),
+            _: 2
+          }, [
+            _ctx.$slots.radio ? {
+              name: "radio",
+              fn: withCtx((scope) => [
+                renderSlot(_ctx.$slots, "radio", mergeProps({ ref_for: true }, scope))
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["value", "disabled"]);
+        }), 128))
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Radio/RadioGroup.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./RadioGroup.vue.js";
+/* empty css                */
+export {
+  _sfc_main as default
+};

package/es/Radio/hooks/useContext.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+import { RadioType, RadioGroupEmits, RadioValue, RadioOption } from '../type';
+import { Size, Props } from '../../_shared/type';
+interface RadioContext {
+    computedValue: Ref<RadioValue | undefined>;
+    type: Ref<RadioType>;
+    disabled: Ref<boolean>;
+    size: Ref<Size>;
+    hasGroup: Ref<boolean>;
+    emits: RadioGroupEmits;
+}
+declare const _default: () => {
+    provide: (props: Props, emits: RadioGroupEmits) => {
+        options: import('vue').ComputedRef<((RadioOption & Record<string, unknown>) | {
+            label: RadioOption;
+            value: RadioOption;
+        })[]>;
+    };
+    inject: () => RadioContext;
+};
+export default _default;

package/es/Radio/hooks/useContext.js

@@ -0,0 +1,65 @@
+import { toRefs, computed, provide, ref, inject } from "vue";
+import "../../node_modules/tinycolor2/esm/tinycolor.js";
+import "../../_shared/utils/dom.js";
+import { isObject } from "../../_shared/utils/is.js";
+import "../../_shared/utils/time.js";
+import { getGlobalConfig } from "../../_shared/utils/global-config.js";
+import useControlValue from "../../_shared/utils/control.js";
+const RADIO_GROUP_CONTEXT_KEY = "radio-group-context";
+const useContext = () => {
+  const provide$1 = (props, emits) => {
+    const {
+      modelValue,
+      defaultValue,
+      disabled,
+      type,
+      options: _options
+    } = toRefs(props);
+    const { size } = getGlobalConfig(props);
+    const computedValue = useControlValue(
+      modelValue,
+      defaultValue.value,
+      (val) => {
+        emits("update:modelValue", val);
+        emits("change", val);
+      }
+    );
+    const options = computed(() => {
+      return _options.value.map((item) => {
+        return isObject(item) ? item : {
+          label: item,
+          value: item
+        };
+      });
+    });
+    provide(RADIO_GROUP_CONTEXT_KEY, {
+      computedValue,
+      type,
+      disabled,
+      size,
+      hasGroup: ref(true),
+      emits
+    });
+    return {
+      options
+    };
+  };
+  const inject$1 = () => {
+    return inject(RADIO_GROUP_CONTEXT_KEY, {
+      computedValue: ref(void 0),
+      disabled: ref(false),
+      type: ref("radio"),
+      size: ref("medium"),
+      hasGroup: ref(false),
+      emits: () => {
+      }
+    });
+  };
+  return {
+    provide: provide$1,
+    inject: inject$1
+  };
+};
+export {
+  useContext as default
+};