@qingmingmu/components 0.1.0-beta.0

package/es/shared/components.BxBfOAnD.d.cts

@@ -0,0 +1,359 @@
+import { InjectionKey, ComputedRef, PropType, defineComponent, ref, computed, watch, onMounted, nextTick, provide, openBlock, createElementBlock, normalizeClass, renderSlot, inject, withKeys, withModifiers, createElementVNode, toDisplayString, createCommentVNode, createVNode, withDirectives, vShow } from 'vue';
+import { _ as _export_sfc } from './components.OJRSZE6i.cjs';
+import { a as Icon } from './components.b5GjJzDh.cjs';
+
+/**
+ * QmMenu 组件类型定义（导航 + 桌面端 task）
+ * 类型先行：MenuKey 同时作为菜单项选中值与子菜单展开标识。
+ */
+/** 菜单项选中值 / 子菜单 key（字符串或数字） */
+type MenuKey = string | number;
+/** 菜单方向：horizontal（顶部导航）/ vertical（侧边导航） */
+type MenuMode = 'horizontal' | 'vertical';
+/** props 声明 */
+declare const menuProps: {
+    /** 受控选中项 key（v-model） */
+    readonly modelValue: {
+        readonly type: PropType<MenuKey | undefined>;
+        readonly default: undefined;
+    };
+    /** 非受控模式的初始选中项 key（未绑定 v-model 时作为默认选中） */
+    readonly defaultSelectedKey: {
+        readonly type: PropType<MenuKey | undefined>;
+        readonly default: undefined;
+    };
+    /** 排列方向 */
+    readonly mode: {
+        readonly type: PropType<MenuMode>;
+        readonly default: "vertical";
+    };
+    /** 初始展开的子菜单 key 列表 */
+    readonly defaultOpenedKeys: {
+        readonly type: PropType<MenuKey[]>;
+        readonly default: () => never[];
+    };
+    /** 垂直模式折叠（只显示图标） */
+    readonly collapse: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+};
+/** emits 声明 */
+interface MenuEmits {
+    'update:modelValue': [key: MenuKey];
+    /** 点击菜单项选中 */
+    'select': [key: MenuKey];
+    /** 子菜单展开/收起后，当前展开的 key 列表 */
+    'openChange': [keys: MenuKey[]];
+}
+/** 菜单上下文（provide/inject 供 QmMenuItem / QmSubMenu 消费） */
+interface MenuContext {
+    /** 排列方向 */
+    mode: ComputedRef<MenuMode>;
+    /** 是否折叠 */
+    collapse: ComputedRef<boolean>;
+    /** 当前选中 key */
+    selectedKey: ComputedRef<MenuKey | undefined>;
+    /** 选中菜单项（父级统一 emit update:modelValue + select） */
+    selectKey: (key: MenuKey) => void;
+    /** 子菜单是否展开 */
+    isOpen: (key: MenuKey) => boolean;
+    /** 切换子菜单展开/收起 */
+    toggleSubMenu: (key: MenuKey) => void;
+}
+/** 注入键 */
+declare const MENU_CONTEXT_KEY: InjectionKey<MenuContext>;
+
+var _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  ...{ name: "QmMenu" },
+  __name: "menu",
+  props: menuProps,
+  emits: ["update:modelValue", "select", "openChange"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    __expose();
+    const props = __props;
+    const emit = __emit;
+    const openedKeys = ref([...props.defaultOpenedKeys]);
+    const innerSelectedKey = ref(props.defaultSelectedKey);
+    const effectiveSelectedKey = computed(
+      () => props.modelValue ?? innerSelectedKey.value
+    );
+    watch(
+      () => props.modelValue,
+      (v) => {
+        if (v !== void 0)
+          innerSelectedKey.value = v;
+      }
+    );
+    const menuRef = ref(null);
+    function focusableItems() {
+      const root = menuRef.value;
+      if (!root)
+        return [];
+      return [
+        ...root.querySelectorAll(
+          '.qm-menu-item:not([aria-disabled="true"]), .qm-sub-menu__trigger:not([aria-disabled="true"])'
+        )
+      ];
+    }
+    function normalizeRoving(target) {
+      const items = focusableItems();
+      for (const el of items) el.setAttribute("tabindex", el === target ? "0" : "-1");
+    }
+    function onMenuFocusin(event) {
+      const target = event.target;
+      if (target && menuRef.value?.contains(target))
+        normalizeRoving(target);
+    }
+    function onMenuKeydown(event) {
+      const items = focusableItems();
+      if (!items.length)
+        return;
+      const current = document.activeElement;
+      let index = current ? items.indexOf(current) : -1;
+      if (event.key === "Home") {
+        event.preventDefault();
+        index = 0;
+      } else if (event.key === "End") {
+        event.preventDefault();
+        index = items.length - 1;
+      } else if (event.key === "ArrowDown" || event.key === "ArrowRight") {
+        event.preventDefault();
+        index = index < 0 ? 0 : (index + 1) % items.length;
+      } else if (event.key === "ArrowUp" || event.key === "ArrowLeft") {
+        event.preventDefault();
+        index = index < 0 ? items.length - 1 : (index - 1 + items.length) % items.length;
+      } else {
+        return;
+      }
+      const target = items[index];
+      if (target) {
+        target.focus();
+        normalizeRoving(target);
+      }
+    }
+    onMounted(() => {
+      void nextTick(() => {
+        const items = focusableItems();
+        if (!items.length)
+          return;
+        const selected = items.find((el) => el.getAttribute("aria-selected") === "true");
+        const initial = selected ?? items[0];
+        normalizeRoving(initial);
+      });
+    });
+    const context = {
+      mode: computed(() => props.mode),
+      collapse: computed(() => props.collapse),
+      selectedKey: effectiveSelectedKey,
+      selectKey: (key) => {
+        innerSelectedKey.value = key;
+        if (props.modelValue !== key)
+          emit("update:modelValue", key);
+        emit("select", key);
+      },
+      isOpen: (key) => openedKeys.value.includes(key),
+      toggleSubMenu: (key) => {
+        const index = openedKeys.value.indexOf(key);
+        if (index >= 0)
+          openedKeys.value.splice(index, 1);
+        else openedKeys.value.push(key);
+        emit("openChange", [...openedKeys.value]);
+      }
+    };
+    provide(MENU_CONTEXT_KEY, context);
+    const __returned__ = { props, emit, openedKeys, innerSelectedKey, effectiveSelectedKey, menuRef, focusableItems, normalizeRoving, onMenuFocusin, onMenuKeydown, context };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+	return openBlock(), createElementBlock(
+		"ul",
+		{
+			ref: "menuRef",
+			class: normalizeClass(["qm-menu", [`qm-menu--${_ctx.mode}`, { "qm-menu--collapsed": _ctx.collapse }]]),
+			"data-qm": "menu",
+			role: "menu",
+			onFocusin: $setup.onMenuFocusin,
+			onKeydown: $setup.onMenuKeydown
+		},
+		[renderSlot(_ctx.$slots, "default")],
+		34
+		/* CLASS, NEED_HYDRATION */
+	);
+}
+var Menu = /*#__PURE__*/ _export_sfc(_sfc_main$2, [["render", _sfc_render$2], ["__file", "F:\\软件开发\\青冥组件系统\\packages\\components\\src\\components\\menu\\menu.vue"]]);
+
+var _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...{ name: "QmMenuItem" },
+  __name: "menu-item",
+  props: {
+    /** 菜单项唯一 key（选中值，即菜单 modelValue） */
+    index: { type: [String, Number], required: true },
+    /** 禁用（不可选中） */
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["select"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    __expose();
+    const props = __props;
+    const emit = __emit;
+    const context = inject(MENU_CONTEXT_KEY, void 0);
+    const isSelected = computed(() => context?.selectedKey.value === props.index);
+    function onClick() {
+      if (props.disabled)
+        return;
+      emit("select", props.index);
+      context?.selectKey?.(props.index);
+    }
+    const __returned__ = { props, emit, context, isSelected, onClick };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+const _hoisted_1$1 = [
+	"aria-selected",
+	"aria-disabled",
+	"tabindex",
+	"onKeydown"
+];
+const _hoisted_2$1 = {
+	class: "qm-menu-item__icon",
+	"aria-hidden": "true"
+};
+const _hoisted_3$1 = { class: "qm-menu-item__label" };
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+	return openBlock(), createElementBlock("li", {
+		class: normalizeClass(["qm-menu-item", {
+			"qm-menu-item--selected": $setup.isSelected,
+			"qm-menu-item--disabled": $props.disabled
+		}]),
+		"data-qm": "menu-item",
+		role: "menuitem",
+		"aria-selected": $setup.isSelected,
+		"aria-disabled": $props.disabled || undefined,
+		tabindex: $props.disabled ? -1 : 0,
+		onClick: $setup.onClick,
+		onKeydown: [withKeys(withModifiers($setup.onClick, ["prevent"]), ["enter"]), withKeys(withModifiers($setup.onClick, ["prevent"]), ["space"])]
+	}, [createElementVNode("span", _hoisted_2$1, [renderSlot(_ctx.$slots, "icon")]), createElementVNode("span", _hoisted_3$1, [renderSlot(_ctx.$slots, "default")])], 42, _hoisted_1$1);
+}
+var menuItem = /*#__PURE__*/ _export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "F:\\软件开发\\青冥组件系统\\packages\\components\\src\\components\\menu\\menu-item.vue"]]);
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "QmSubMenu" },
+  __name: "sub-menu",
+  props: {
+    /** 子菜单唯一 key（展开状态标识） */
+    index: { type: [String, Number], required: true },
+    /** 子菜单标题 */
+    title: { type: String, default: "" },
+    /** 禁用（不可展开） */
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props, { expose: __expose }) {
+    __expose();
+    const props = __props;
+    const context = inject(MENU_CONTEXT_KEY, void 0);
+    const open = computed(() => context?.isOpen(props.index) ?? false);
+    const popupRef = ref(null);
+    const flip = ref(false);
+    watch(open, async (val) => {
+      if (!val) {
+        flip.value = false;
+        return;
+      }
+      await nextTick();
+      const popup = popupRef.value;
+      if (!popup || context?.mode.value !== "horizontal")
+        return;
+      const rect = popup.getBoundingClientRect();
+      flip.value = rect.bottom > window.innerHeight;
+    });
+    function toggle() {
+      if (props.disabled)
+        return;
+      context?.toggleSubMenu?.(props.index);
+    }
+    const __returned__ = { props, context, open, popupRef, flip, toggle, get QmIcon() {
+      return Icon;
+    } };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+const _hoisted_1 = [
+	"aria-expanded",
+	"aria-disabled",
+	"tabindex",
+	"onKeydown"
+];
+const _hoisted_2 = {
+	class: "qm-sub-menu__icon",
+	"aria-hidden": "true"
+};
+const _hoisted_3 = {
+	key: 0,
+	class: "qm-sub-menu__title"
+};
+const _hoisted_4 = {
+	key: 1,
+	class: "qm-sub-menu__arrow",
+	"aria-hidden": "true"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	return openBlock(), createElementBlock(
+		"li",
+		{
+			class: normalizeClass(["qm-sub-menu", {
+				"qm-sub-menu--open": $setup.open,
+				"qm-sub-menu--disabled": $props.disabled,
+				"qm-sub-menu--collapsed": $setup.context?.collapse.value
+			}]),
+			"data-qm": "sub-menu",
+			role: "none"
+		},
+		[createElementVNode("div", {
+			class: "qm-sub-menu__trigger",
+			role: "menuitem",
+			"aria-haspopup": true,
+			"aria-expanded": $setup.open,
+			"aria-disabled": $props.disabled || undefined,
+			tabindex: $props.disabled ? -1 : 0,
+			onClick: $setup.toggle,
+			onKeydown: [withKeys(withModifiers($setup.toggle, ["prevent"]), ["enter"]), withKeys(withModifiers($setup.toggle, ["prevent"]), ["space"])]
+		}, [
+			createElementVNode("span", _hoisted_2, [renderSlot(_ctx.$slots, "icon")]),
+			!$setup.context?.collapse.value ? (openBlock(), createElementBlock(
+				"span",
+				_hoisted_3,
+				toDisplayString($props.title),
+				1
+				/* TEXT */
+			)) : createCommentVNode("v-if", true),
+			!$setup.context?.collapse.value ? (openBlock(), createElementBlock("span", _hoisted_4, [createVNode($setup["QmIcon"], {
+				name: "chevron-down",
+				class: "qm-sub-menu__arrow-icon"
+			})])) : createCommentVNode("v-if", true)
+		], 40, _hoisted_1), withDirectives(createElementVNode(
+			"ul",
+			{
+				ref: "popupRef",
+				class: normalizeClass(["qm-sub-menu__popup", { "qm-sub-menu__popup--flip": $setup.flip }]),
+				role: "menu"
+			},
+			[renderSlot(_ctx.$slots, "default")],
+			2
+			/* CLASS */
+		), [[vShow, $setup.open]])],
+		2
+		/* CLASS */
+	);
+}
+var subMenu = /*#__PURE__*/ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "F:\\软件开发\\青冥组件系统\\packages\\components\\src\\components\\menu\\sub-menu.vue"]]);
+
+export { MENU_CONTEXT_KEY as M, Menu as e, menuProps as f, menuItem as m, subMenu as s };
+export type { MenuContext as a, MenuEmits as b, MenuKey as c, MenuMode as d };

package/es/shared/components.BxOtwzkp.cjs

@@ -0,0 +1,349 @@
+'use strict';
+
+const vue = require('vue');
+const exportHelper = require('./components.DUidQ77e.cjs');
+
+const radioProps = {
+  /** 受控值：单独使用即自身选中态；组模式下由 QmRadioGroup 注入，勿直传 */
+  modelValue: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  /** 选项值（组模式下用于选中比对；必填） */
+  value: {
+    type: [String, Number, Boolean],
+    required: true
+  },
+  /** 禁用单项（整组禁用由 group.disabled 统一接管） */
+  disabled: { type: Boolean, default: false },
+  /** 标签文案（缺省时回退默认插槽内容） */
+  label: { type: String, default: "" },
+  /** 尺寸：缺省回退组 size，再回退 medium */
+  size: {
+    type: String,
+    default: void 0
+  },
+  /** 原生 name：组模式下由 group 注入以共享浏览器原生单选行为 */
+  name: { type: String, default: "" }
+};
+const radioGroupProps = {
+  /** 受控值（v-model）：选中项的 value */
+  modelValue: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  /** 整组禁用 */
+  disabled: { type: Boolean, default: false },
+  /** 统一尺寸（子项未单独指定时回退到此） */
+  size: { type: String, default: "medium" },
+  /** 排列方向 */
+  direction: {
+    type: String,
+    default: "horizontal"
+  },
+  /** 原生 name：组内所有 QmRadio 共享，确保浏览器原生单选行为 */
+  name: { type: String, default: "" }
+};
+
+const RADIO_GROUP_KEY = Symbol("qm-radio-group");
+function findNextEnabledIndex(items, fromIndex, delta) {
+  const len = items.length;
+  if (len === 0)
+    return -1;
+  let i = fromIndex;
+  for (let step = 0; step < len; step++) {
+    i = (i + delta + len) % len;
+    if (!items[i].disabled.value)
+      return i;
+  }
+  return -1;
+}
+function isNextKey(key) {
+  return key === "ArrowDown" || key === "ArrowRight";
+}
+function isPrevKey(key) {
+  return key === "ArrowUp" || key === "ArrowLeft";
+}
+function useRadioGroup(options) {
+  const { modelValue, disabled, size, name, emitUpdate, emitChange } = options;
+  const items = vue.shallowRef([]);
+  function register(item) {
+    if (!items.value.includes(item))
+      items.value.push(item);
+  }
+  function unregister(item) {
+    const idx = items.value.indexOf(item);
+    if (idx >= 0)
+      items.value.splice(idx, 1);
+  }
+  function select(value) {
+    if (disabled.value)
+      return;
+    if (modelValue.value === value)
+      return;
+    emitUpdate(value);
+    emitChange(value);
+  }
+  function onItemKeydown(item, event) {
+    if (disabled.value || item.disabled.value)
+      return;
+    const key = event.key;
+    let delta = 0;
+    if (isNextKey(key))
+      delta = 1;
+    else if (isPrevKey(key))
+      delta = -1;
+    else return;
+    event.preventDefault();
+    const fromIndex = items.value.indexOf(item);
+    const nextIndex = findNextEnabledIndex(items.value, fromIndex, delta);
+    if (nextIndex < 0)
+      return;
+    const next = items.value[nextIndex];
+    if (!next)
+      return;
+    select(next.value);
+    next.el.value?.focus();
+  }
+  const ctx = {
+    modelValue,
+    disabled,
+    size,
+    name,
+    items,
+    select,
+    register,
+    unregister,
+    onItemKeydown
+  };
+  vue.provide(RADIO_GROUP_KEY, ctx);
+  return ctx;
+}
+function useRadioItem(options) {
+  const { value, disabled, size, name, modelValue, el, emitUpdate, emitChange } = options;
+  const group = vue.inject(RADIO_GROUP_KEY, void 0);
+  const innerValue = vue.ref(modelValue.value);
+  vue.watch(modelValue, (val) => innerValue.value = val);
+  const inGroup = vue.computed(() => Boolean(group));
+  const currentValue = vue.computed(() => {
+    if (group)
+      return group.modelValue.value;
+    return modelValue.value ?? innerValue.value;
+  });
+  const checked = vue.computed(() => currentValue.value === value.value);
+  const isDisabled = vue.computed(() => (group ? group.disabled.value : false) || disabled.value);
+  const effectiveSize = vue.computed(() => {
+    if (size.value)
+      return size.value;
+    if (group)
+      return group.size.value;
+    return "medium";
+  });
+  const effectiveName = vue.computed(() => {
+    if (group && group.name.value)
+      return group.name.value;
+    return name.value;
+  });
+  const tabindex = vue.computed(() => {
+    if (isDisabled.value)
+      return -1;
+    if (group)
+      return checked.value ? 0 : -1;
+    return 0;
+  });
+  function check() {
+    if (isDisabled.value)
+      return;
+    if (group) {
+      group.select(value.value);
+      return;
+    }
+    if (checked.value)
+      return;
+    emitUpdate(value.value);
+    emitChange(value.value);
+    innerValue.value = value.value;
+  }
+  const itemRef = {
+    get value() {
+      return value.value;
+    },
+    disabled,
+    el
+  };
+  function onKeydown(event) {
+    if (isDisabled.value)
+      return;
+    if (group && (isNextKey(event.key) || isPrevKey(event.key))) {
+      group.onItemKeydown(itemRef, event);
+      return;
+    }
+    if (event.key === " " || event.key === "Enter") {
+      event.preventDefault();
+      check();
+    }
+  }
+  function registerSelf() {
+    group?.register(itemRef);
+  }
+  vue.onBeforeUnmount(() => {
+    group?.unregister(itemRef);
+  });
+  return {
+    inGroup,
+    checked,
+    isDisabled,
+    effectiveSize,
+    effectiveName,
+    tabindex,
+    check,
+    onKeydown,
+    registerSelf
+  };
+}
+
+const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "QmRadio" },
+  __name: "radio",
+  props: radioProps,
+  emits: ["update:modelValue", "change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    __expose();
+    const props = __props;
+    const emit = __emit;
+    const rootRef = vue.ref(null);
+    const inputRef = vue.ref(null);
+    const item = useRadioItem({
+      value: vue.toRef(props, "value"),
+      disabled: vue.toRef(props, "disabled"),
+      size: vue.toRef(props, "size"),
+      name: vue.toRef(props, "name"),
+      modelValue: vue.toRef(props, "modelValue"),
+      el: rootRef,
+      emitUpdate: (value) => emit("update:modelValue", value),
+      emitChange: (value) => emit("change", value)
+    });
+    const { checked, isDisabled, effectiveSize, effectiveName, tabindex, check, onKeydown } = item;
+    const rootClass = vue.computed(() => [
+      "qm-radio",
+      `qm-radio--${effectiveSize.value}`,
+      {
+        "qm-radio--checked": checked.value,
+        "qm-radio--disabled": isDisabled.value
+      }
+    ]);
+    function onChange() {
+      check();
+    }
+    vue.onMounted(() => {
+      item.registerSelf();
+    });
+    const __returned__ = { props, emit, rootRef, inputRef, item, checked, isDisabled, effectiveSize, effectiveName, tabindex, check, onKeydown, rootClass, onChange };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+const _hoisted_1$1 = [
+	"name",
+	"value",
+	"checked",
+	"disabled",
+	"tabindex",
+	"aria-checked"
+];
+const _hoisted_2 = { class: "qm-radio__label" };
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+	return vue.openBlock(), vue.createElementBlock(
+		"label",
+		{
+			ref: "rootRef",
+			class: vue.normalizeClass($setup.rootClass)
+		},
+		[
+			vue.createCommentVNode(" 原生 radio：视觉隐藏但覆盖整个 label，保留聚焦/点击/键盘可访问性 "),
+			vue.createElementVNode("input", {
+				ref: "inputRef",
+				class: "qm-radio__original",
+				type: "radio",
+				name: $setup.effectiveName,
+				value: _ctx.value,
+				checked: $setup.checked,
+				disabled: $setup.isDisabled,
+				tabindex: $setup.tabindex,
+				"aria-checked": $setup.checked,
+				onChange: $setup.onChange,
+				onKeydown: _cache[0] || (_cache[0] = (...args) => $setup.onKeydown && $setup.onKeydown(...args))
+			}, null, 40, _hoisted_1$1),
+			vue.createCommentVNode(" 自定义圆点（视觉层，aria-hidden 避免与原生 input 语义重复；选中态纯色填满） "),
+			_cache[1] || (_cache[1] = vue.createElementVNode(
+				"span",
+				{
+					class: "qm-radio__dot",
+					"aria-hidden": "true"
+				},
+				null,
+				-1
+				/* CACHED */
+			)),
+			vue.createCommentVNode(" 文案 "),
+			vue.createElementVNode("span", _hoisted_2, [vue.renderSlot(_ctx.$slots, "default", {}, () => [vue.createTextVNode(
+				vue.toDisplayString(_ctx.label),
+				1
+				/* TEXT */
+			)])])
+		],
+		2
+		/* CLASS */
+	);
+}
+const Radio = /*#__PURE__*/ exportHelper._export_sfc(_sfc_main$1, [["render", _sfc_render$1], ["__file", "F:\\软件开发\\青冥组件系统\\packages\\components\\src\\components\\radio\\radio.vue"]]);
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "QmRadioGroup" },
+  __name: "radio-group",
+  props: radioGroupProps,
+  emits: ["update:modelValue", "change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    __expose();
+    const props = __props;
+    const emit = __emit;
+    useRadioGroup({
+      modelValue: vue.toRef(props, "modelValue"),
+      disabled: vue.toRef(props, "disabled"),
+      size: vue.toRef(props, "size"),
+      name: vue.toRef(props, "name"),
+      emitUpdate: (value) => emit("update:modelValue", value),
+      emitChange: (value) => emit("change", value)
+    });
+    const rootClass = vue.computed(() => [
+      "qm-radio-group",
+      `qm-radio-group--${props.direction}`,
+      { "qm-radio-group--disabled": props.disabled }
+    ]);
+    const __returned__ = { props, emit, rootClass };
+    Object.defineProperty(__returned__, "__isScriptSetup", { enumerable: false, value: true });
+    return __returned__;
+  }
+});
+
+const _hoisted_1 = ["aria-disabled"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+	return vue.openBlock(), vue.createElementBlock("div", {
+		class: vue.normalizeClass($setup.rootClass),
+		role: "radiogroup",
+		"aria-disabled": _ctx.disabled || undefined
+	}, [vue.renderSlot(_ctx.$slots, "default")], 10, _hoisted_1);
+}
+const radioGroup = /*#__PURE__*/ exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "F:\\软件开发\\青冥组件系统\\packages\\components\\src\\components\\radio\\radio-group.vue"]]);
+
+exports.RADIO_GROUP_KEY = RADIO_GROUP_KEY;
+exports.Radio = Radio;
+exports.findNextEnabledIndex = findNextEnabledIndex;
+exports.isNextKey = isNextKey;
+exports.isPrevKey = isPrevKey;
+exports.radioGroup = radioGroup;
+exports.radioGroupProps = radioGroupProps;
+exports.radioProps = radioProps;
+exports.useRadioGroup = useRadioGroup;
+exports.useRadioItem = useRadioItem;