@raxium/vue 0.1.0 → 0.1.1

package/dist/components/progress/ProgressArc.js

@@ -0,0 +1,130 @@
+import { computed, createBlock, createElementVNode, createPropsRestProxy, createVNode, defineComponent, mergeProps, normalizeStyle, openBlock, unref, useTemplateRef, withCtx } from "vue";
+import { useForwardProps } from "@ark-ui/vue";
+import { ark } from "@ark-ui/vue/factory";
+import { Progress, useProgressContext } from "@ark-ui/vue/progress";
+import { getNodeCssVar } from "@raxium/shared/css";
+import { clsx } from "@raxium/themes/utils";
+import { useCustomTheme } from "../../composables/useTheme.js";
+import { omit } from "es-toolkit";
+import { useRangeTransfer } from "./useRangeTransfer.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "ProgressArc",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        theta: {
+            default: 60
+        },
+        variant: {
+            default: "default"
+        },
+        ui: {},
+        theme: {},
+        asChild: {
+            type: Boolean
+        }
+    },
+    setup (__props) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "theme",
+            "theta",
+            "ui",
+            "variant"
+        ]);
+        const forwarded = useForwardProps(props);
+        const context = useProgressContext();
+        const trackRef = useTemplateRef("track");
+        const trackProps = computed(()=>{
+            const _props = context.value.getCircleTrackProps();
+            delete _props.style?.strokeDasharray;
+            delete _props.style?.strokeDashoffset;
+            return _props;
+        });
+        const rangeProps = computed(()=>{
+            const _props = context.value.getCircleRangeProps();
+            delete _props.style?.strokeDasharray;
+            delete _props.style?.strokeDashoffset;
+            delete _props.style?.transform;
+            delete _props.style?.transformOrigin;
+            return _props;
+        });
+        const radius = computed(()=>parseInt(getNodeCssVar(trackRef.value?.$el, "--radius", "24px")));
+        const arc = computed(()=>Math.ceil((360 - __props.theta) * Math.PI * radius.value / 180));
+        const progress = computed(()=>arc.value - (context.value.percent ?? 0) / 100 * arc.value);
+        const rangeRef = useTemplateRef("range");
+        const { styles: transferStyles } = useRangeTransfer(rangeRef, computed(()=>__props.variant), "stroke");
+        const theme = useCustomTheme(()=>__props.theme);
+        const themeRest = computed(()=>omit(theme.value, [
+                "size"
+            ]));
+        const crafts = computed(()=>theme.value.crafts.tvProgress());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(Progress).Circle, mergeProps(unref(forwarded), {
+                class: crafts.value.circle({
+                    class: unref(clsx)(__props.ui?.circle, __props.class),
+                    size: "string" == typeof unref(theme).size ? unref(theme).size : "base",
+                    ...themeRest.value
+                }),
+                "data-variant": __props.variant,
+                style: "number" == typeof unref(theme).size && {
+                    "--size": `${unref(theme).size}px`
+                }
+            }), {
+                default: withCtx(()=>[
+                        createElementVNode("g", {
+                            fill: "none",
+                            style: normalizeStyle({
+                                transformOrigin: "center center",
+                                transform: `rotate(${90 + __props.theta / 2}deg)`
+                            })
+                        }, [
+                            createVNode(unref(ark).circle, mergeProps(trackProps.value, {
+                                ref: "track",
+                                class: crafts.value.circleTrack({
+                                    class: unref(clsx)(__props.ui?.circleTrack),
+                                    ...themeRest.value
+                                }),
+                                "data-variant": __props.variant,
+                                "stroke-dasharray": `${arc.value} 1000`,
+                                "stroke-dashoffset": "0"
+                            }), null, 16, [
+                                "class",
+                                "data-variant",
+                                "stroke-dasharray"
+                            ]),
+                            createVNode(unref(ark).circle, mergeProps(rangeProps.value, {
+                                ref: "range",
+                                class: crafts.value.circleRange({
+                                    class: unref(clsx)(__props.ui?.circleRange),
+                                    ...themeRest.value
+                                }),
+                                "data-variant": __props.variant,
+                                "stroke-dasharray": `${arc.value} 1000`,
+                                "stroke-dashoffset": progress.value,
+                                style: unref(transferStyles)
+                            }), null, 16, [
+                                "class",
+                                "data-variant",
+                                "stroke-dasharray",
+                                "stroke-dashoffset",
+                                "style"
+                            ])
+                        ], 4)
+                    ]),
+                _: 1
+            }, 16, [
+                "class",
+                "data-variant",
+                "style"
+            ]));
+    }
+});
+const ProgressArc = _sfc_main;
+export default ProgressArc;

package/dist/components/progress/ProgressArc.vue.d.ts

@@ -0,0 +1,4 @@
+import type { ProgressArcProps } from '.';
+declare const __VLS_export: import("vue").DefineComponent<ProgressArcProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressArcProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/progress/ProgressCircle.js

@@ -0,0 +1,89 @@
+import { computed, createBlock, createPropsRestProxy, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, unref, useTemplateRef, withCtx } from "vue";
+import { useForwardProps } from "@ark-ui/vue";
+import { Progress } from "@ark-ui/vue/progress";
+import { clsx } from "@raxium/themes/utils";
+import { useCustomTheme } from "../../composables/useTheme.js";
+import { omit } from "es-toolkit";
+import { useRangeTransfer } from "./useRangeTransfer.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "ProgressCircle",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        variant: {
+            default: "default"
+        },
+        ui: {},
+        theme: {},
+        asChild: {
+            type: Boolean
+        }
+    },
+    setup (__props) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "theme",
+            "variant",
+            "ui"
+        ]);
+        const forwarded = useForwardProps(props);
+        const rangeRef = useTemplateRef("range");
+        const { styles: transferStyles } = useRangeTransfer(rangeRef, computed(()=>__props.variant), "stroke");
+        const theme = useCustomTheme(()=>__props.theme);
+        const themeRest = computed(()=>omit(theme.value, [
+                "size"
+            ]));
+        const crafts = computed(()=>theme.value.crafts.tvProgress());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(Progress).Circle, mergeProps(unref(forwarded), {
+                class: crafts.value.circle({
+                    class: unref(clsx)(__props.ui?.circle, __props.class),
+                    size: "string" == typeof unref(theme).size ? unref(theme).size : "base",
+                    ...themeRest.value
+                }),
+                "data-variant": __props.variant,
+                style: "number" == typeof unref(theme).size && {
+                    "--size": `${unref(theme).size}px`
+                }
+            }), {
+                default: withCtx(()=>[
+                        createVNode(unref(Progress).CircleTrack, {
+                            class: normalizeClass(crafts.value.circleTrack({
+                                class: unref(clsx)(__props.ui?.circleTrack),
+                                ...themeRest.value
+                            })),
+                            "data-variant": __props.variant
+                        }, null, 8, [
+                            "class",
+                            "data-variant"
+                        ]),
+                        createVNode(unref(Progress).CircleRange, {
+                            ref: "range",
+                            class: normalizeClass(crafts.value.circleRange({
+                                class: unref(clsx)(__props.ui?.circleRange),
+                                ...themeRest.value
+                            })),
+                            "data-variant": __props.variant,
+                            style: normalizeStyle(unref(transferStyles))
+                        }, null, 8, [
+                            "class",
+                            "data-variant",
+                            "style"
+                        ])
+                    ]),
+                _: 1
+            }, 16, [
+                "class",
+                "data-variant",
+                "style"
+            ]));
+    }
+});
+const ProgressCircle = _sfc_main;
+export default ProgressCircle;

package/dist/components/progress/ProgressCircle.vue.d.ts

@@ -0,0 +1,4 @@
+import type { ProgressCircleProps } from '.';
+declare const __VLS_export: import("vue").DefineComponent<ProgressCircleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressCircleProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/progress/ProgressLinear.js

@@ -0,0 +1,74 @@
+import { computed, createBlock, createPropsRestProxy, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, unref, useTemplateRef, withCtx } from "vue";
+import { useForwardProps } from "@ark-ui/vue";
+import { Progress, useProgressContext } from "@ark-ui/vue/progress";
+import { clsx } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+import { useRangeTransfer } from "./useRangeTransfer.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "ProgressLinear",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        variant: {
+            default: "default"
+        },
+        ui: {},
+        asChild: {
+            type: Boolean
+        },
+        theme: {}
+    },
+    setup (__props) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "theme",
+            "variant",
+            "ui"
+        ]);
+        const forwarded = useForwardProps(props);
+        const context = useProgressContext();
+        const itemProps = computed(()=>context.value.getTrackProps());
+        const rangeRef = useTemplateRef("range");
+        const { styles: transferStyles } = useRangeTransfer(rangeRef, computed(()=>__props.variant), "background");
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvProgress());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(Progress).Track, mergeProps(unref(forwarded), {
+                class: crafts.value.track({
+                    class: unref(clsx)(__props.ui?.track, __props.class),
+                    orientation: itemProps.value["data-orientation"] ?? "horizontal",
+                    ...unref(theme)
+                }),
+                "data-variant": __props.variant
+            }), {
+                default: withCtx(()=>[
+                        createVNode(unref(Progress).Range, {
+                            ref: "range",
+                            class: normalizeClass(crafts.value.range({
+                                class: unref(clsx)(__props.ui?.range),
+                                orientation: itemProps.value["data-orientation"] ?? "horizontal",
+                                ...unref(theme)
+                            })),
+                            "data-variant": __props.variant,
+                            style: normalizeStyle(unref(transferStyles))
+                        }, null, 8, [
+                            "class",
+                            "data-variant",
+                            "style"
+                        ])
+                    ]),
+                _: 1
+            }, 16, [
+                "class",
+                "data-variant"
+            ]));
+    }
+});
+const ProgressLinear = _sfc_main;
+export default ProgressLinear;

package/dist/components/progress/ProgressLinear.vue.d.ts

@@ -0,0 +1,4 @@
+import type { ProgressLinearProps } from '.';
+declare const __VLS_export: import("vue").DefineComponent<ProgressLinearProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressLinearProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/progress/index.d.ts

@@ -0,0 +1,6 @@
+export { default as Progress } from './Progress.vue';
+export { default as ProgressArc } from './ProgressArc.vue';
+export { default as ProgressCircle } from './ProgressCircle.vue';
+export { default as ProgressLinear } from './ProgressLinear.vue';
+export * from './props';
+export { ProgressLabel, ProgressValueText, ProgressView } from '@ark-ui/vue/progress';

package/dist/components/progress/index.js

@@ -0,0 +1,6 @@
+export * from "./props.js";
+export { default as Progress } from "./Progress.js";
+export { default as ProgressArc } from "./ProgressArc.js";
+export { default as ProgressCircle } from "./ProgressCircle.js";
+export { default as ProgressLinear } from "./ProgressLinear.js";
+export { ProgressLabel, ProgressValueText, ProgressView } from "@ark-ui/vue/progress";

package/dist/components/progress/props.d.ts

@@ -0,0 +1,39 @@
+import type { ProgressCircleBaseProps, ProgressRootBaseProps, ProgressTrackBaseProps } from '@ark-ui/vue';
+import type { ProgressVariants } from '@raxium/themes/default';
+import type { ThemeCrafts, ThemeNoCrafts } from '../../providers';
+import type { HTMLAttributes } from 'vue';
+export interface ProgressCircleTheme extends Omit<ThemeNoCrafts, 'size'> {
+    size?: ProgressVariants['size'] | number;
+}
+export interface ProgressProps extends ProgressRootBaseProps, ThemeCrafts<'tvProgress'> {
+    class?: HTMLAttributes['class'];
+}
+export interface ProgressArcProps extends ProgressCircleBaseProps {
+    class?: HTMLAttributes['class'];
+    theta?: number;
+    variant?: 'default' | 'transfer';
+    ui?: {
+        circle?: HTMLAttributes['class'];
+        circleTrack?: HTMLAttributes['class'];
+        circleRange?: HTMLAttributes['class'];
+    };
+    theme?: Omit<ProgressCircleTheme, 'crafts'>;
+}
+export interface ProgressCircleProps extends ProgressCircleBaseProps {
+    class?: HTMLAttributes['class'];
+    variant?: 'default' | 'transfer';
+    ui?: {
+        circle?: HTMLAttributes['class'];
+        circleTrack?: HTMLAttributes['class'];
+        circleRange?: HTMLAttributes['class'];
+    };
+    theme?: Omit<ProgressCircleTheme, 'crafts'>;
+}
+export interface ProgressLinearProps extends ProgressTrackBaseProps, ThemeNoCrafts {
+    class?: HTMLAttributes['class'];
+    variant?: 'default' | 'robbin' | 'transfer';
+    ui?: {
+        track?: HTMLAttributes['class'];
+        range?: HTMLAttributes['class'];
+    };
+}

package/dist/components/progress/useRangeTransfer.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+export declare function useRangeTransfer(range: Ref<{
+    $el: HTMLDivElement;
+} | null>, variant: Ref<'default' | 'robbin' | 'transfer'>, attribute?: 'background' | 'stroke'): {
+    styles: {
+        [attribute]: string;
+    };
+};

package/dist/components/progress/useRangeTransfer.js

@@ -0,0 +1,51 @@
+import { useProgressContext } from "@ark-ui/vue";
+import { colorHex2RgbObject, colorLab2RgbObject, detectCssColorType } from "@raxium/shared/color";
+import { getNodeCssVar } from "@raxium/shared/css";
+import { computed, reactive, watchEffect } from "vue";
+function useRangeTransfer(range, variant, attribute = 'background') {
+    if ('transfer' === variant.value) {
+        const context = useProgressContext();
+        const step = computed(()=>(context.value.percent ?? 0) / 100);
+        const styles = reactive({
+            [attribute]: ''
+        });
+        watchEffect(()=>{
+            const from = detectCssColorType(getNodeCssVar(range.value?.$el, '--transfer-from', '#000'));
+            const to = detectCssColorType(getNodeCssVar(range.value?.$el, '--transfer-to', '#fff'));
+            if (from.type !== to.type) {
+                console.error(new Error('transfer indicator from and to must be same color type'));
+                return {};
+            }
+            switch(from.type){
+                case 'hex':
+                case 'hexa':
+                    {
+                        const fromRGB = colorHex2RgbObject(from.value);
+                        const toRGB = colorHex2RgbObject(to.value);
+                        styles[attribute] = `rgb(${fromRGB.r + (toRGB.r - fromRGB.r) * step.value} ${fromRGB.g + (toRGB.g - fromRGB.g) * step.value} ${fromRGB.b + (toRGB.b - fromRGB.b) * step.value})`;
+                        break;
+                    }
+                case 'rgb':
+                case 'rgba':
+                    styles[attribute] = `rgb(${from.value.r + (to.value.r - from.value.r) * step.value} ${from.value.g + (to.value.g - from.value.g) * step.value} ${from.value.b + (to.value.b - from.value.b) * step.value})`;
+                    break;
+                case 'lab':
+                    {
+                        const fromRGB = colorLab2RgbObject(from.value);
+                        const toRGB = colorLab2RgbObject(to.value);
+                        styles[attribute] = `rgb(${fromRGB.r + (toRGB.r - fromRGB.r) * step.value} ${fromRGB.g + (toRGB.g - fromRGB.g) * step.value} ${fromRGB.b + (toRGB.b - fromRGB.b) * step.value})`;
+                        break;
+                    }
+            }
+        }, {
+            flush: 'post'
+        });
+        return {
+            styles
+        };
+    }
+    return {
+        styles: {}
+    };
+}
+export { useRangeTransfer };

package/dist/components/radio-group/RadioGroup.js

@@ -0,0 +1,88 @@
+import { computed, createBlock, createPropsRestProxy, createVNode, defineComponent, normalizeClass, openBlock, renderSlot, unref, withCtx } from "vue";
+import { RadioGroup, useRadioGroup } from "@ark-ui/vue/radio-group";
+import { useForwardExpose, useForwardProps } from "@ark-ui/vue/utils";
+import { clsx } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+import { ThemeProvider } from "../../providers/theme/index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "RadioGroup",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        modelValue: {},
+        defaultValue: {},
+        disabled: {
+            type: Boolean
+        },
+        form: {},
+        id: {},
+        ids: {},
+        invalid: {
+            type: Boolean
+        },
+        name: {},
+        orientation: {},
+        readOnly: {
+            type: Boolean
+        },
+        required: {
+            type: Boolean
+        },
+        asChild: {
+            type: Boolean
+        },
+        theme: {}
+    },
+    emits: [
+        "valueChange",
+        "update:modelValue"
+    ],
+    setup (__props, { expose: __expose, emit: __emit }) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "theme"
+        ]);
+        const emit = __emit;
+        const radioGroup = useRadioGroup(useForwardProps(props), emit);
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvRadioGroup());
+        __expose({
+            $api: radioGroup
+        });
+        useForwardExpose();
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(RadioGroup).RootProvider, {
+                value: unref(radioGroup),
+                class: normalizeClass(crafts.value.root({
+                    class: unref(clsx)(__props.class),
+                    ...unref(theme)
+                }))
+            }, {
+                default: withCtx(()=>[
+                        createVNode(unref(ThemeProvider), {
+                            value: unref(theme)
+                        }, {
+                            default: withCtx(()=>[
+                                    renderSlot(_ctx.$slots, "label"),
+                                    renderSlot(_ctx.$slots, "default")
+                                ]),
+                            _: 3
+                        }, 8, [
+                            "value"
+                        ])
+                    ]),
+                _: 3
+            }, 8, [
+                "value",
+                "class"
+            ]));
+    }
+});
+const radio_group_RadioGroup = _sfc_main;
+export default radio_group_RadioGroup;

package/dist/components/radio-group/RadioGroupItem.js

@@ -0,0 +1,135 @@
+import { computed, createBlock, createCommentVNode, createPropsRestProxy, createTextVNode, createVNode, defineComponent, guardReactiveProps, mergeProps, normalizeClass, normalizeProps, openBlock, renderSlot, toDisplayString, unref, withCtx } from "vue";
+import { RadioGroup } from "@ark-ui/vue/radio-group";
+import { useForwardProps } from "@ark-ui/vue/utils";
+import { clsx } from "@raxium/themes/utils";
+import { useTheme } from "../../composables/useTheme.js";
+import { Check, Circle } from "lucide-vue-next";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "RadioGroupItem",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        label: {},
+        variant: {
+            default: "default"
+        },
+        ui: {},
+        value: {},
+        disabled: {
+            type: Boolean
+        },
+        invalid: {
+            type: Boolean
+        },
+        asChild: {
+            type: Boolean
+        },
+        theme: {}
+    },
+    setup (__props) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "theme",
+            "label",
+            "ui",
+            "variant"
+        ]);
+        const forwarded = useForwardProps(props);
+        const theme = useTheme(()=>__props.theme);
+        const crafts = computed(()=>theme.value.crafts.tvRadioGroup());
+        return (_ctx, _cache)=>(openBlock(), createBlock(unref(RadioGroup).Item, mergeProps(unref(forwarded), {
+                class: crafts.value.item({
+                    class: unref(clsx)(__props.ui?.root, __props.class),
+                    ...unref(theme)
+                })
+            }), {
+                default: withCtx(()=>[
+                        createVNode(unref(RadioGroup).ItemContext, null, {
+                            default: withCtx((context)=>[
+                                    renderSlot(_ctx.$slots, "control", normalizeProps(guardReactiveProps(context)), ()=>[
+                                            createVNode(unref(RadioGroup).ItemControl, {
+                                                class: normalizeClass(crafts.value.itemControl({
+                                                    class: unref(clsx)(__props.ui?.control),
+                                                    variant: __props.variant,
+                                                    ...unref(theme)
+                                                })),
+                                                "data-variant": __props.variant
+                                            }, {
+                                                default: withCtx(()=>[
+                                                        "default" === __props.variant ? (openBlock(), createBlock(unref(Circle), {
+                                                            key: 0,
+                                                            class: normalizeClass(crafts.value.itemIndicator({
+                                                                class: unref(clsx)(__props.ui?.indicator),
+                                                                variant: __props.variant,
+                                                                ...unref(theme)
+                                                            })),
+                                                            "data-state": context.checked ? "checked" : "unchecked",
+                                                            "data-variant": __props.variant,
+                                                            hidden: context.checked ? void 0 : true
+                                                        }, null, 8, [
+                                                            "class",
+                                                            "data-state",
+                                                            "data-variant",
+                                                            "hidden"
+                                                        ])) : createCommentVNode("", true),
+                                                        "checkbox" === __props.variant ? (openBlock(), createBlock(unref(Check), {
+                                                            key: 1,
+                                                            class: normalizeClass(crafts.value.itemIndicator({
+                                                                class: unref(clsx)(__props.ui?.indicator),
+                                                                variant: __props.variant,
+                                                                ...unref(theme)
+                                                            })),
+                                                            "data-state": context.checked ? "checked" : "unchecked",
+                                                            "data-variant": __props.variant,
+                                                            hidden: context.checked ? void 0 : true
+                                                        }, null, 8, [
+                                                            "class",
+                                                            "data-state",
+                                                            "data-variant",
+                                                            "hidden"
+                                                        ])) : createCommentVNode("", true)
+                                                    ]),
+                                                _: 2
+                                            }, 1032, [
+                                                "class",
+                                                "data-variant"
+                                            ])
+                                        ]),
+                                    renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(context)), ()=>[
+                                            __props.label ? (openBlock(), createBlock(unref(RadioGroup).ItemText, {
+                                                key: 0,
+                                                class: normalizeClass(crafts.value.itemText({
+                                                    class: unref(clsx)(__props.ui?.text),
+                                                    ...unref(theme)
+                                                }))
+                                            }, {
+                                                default: withCtx(()=>[
+                                                        createTextVNode(toDisplayString(__props.label), 1)
+                                                    ]),
+                                                _: 1
+                                            }, 8, [
+                                                "class"
+                                            ])) : createCommentVNode("", true)
+                                        ]),
+                                    createVNode(unref(RadioGroup).ItemHiddenInput, {
+                                        class: "hidden"
+                                    })
+                                ]),
+                            _: 3
+                        })
+                    ]),
+                _: 3
+            }, 16, [
+                "class"
+            ]));
+    }
+});
+const RadioGroupItem = _sfc_main;
+export default RadioGroupItem;