iryx-ui 0.0.1 → 0.2.0

package/dist/components/Checkbox.js

@@ -0,0 +1,5 @@
+import e from "./Checkbox.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/Checkbox.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/Checkbox.vue.d.ts

@@ -0,0 +1,46 @@
+import type { CheckboxRootProps } from 'reka-ui';
+export interface CheckboxProps extends CheckboxRootProps {
+    /** Text shown beside the box. Also makes the text clickable. */
+    label?: string;
+    /** Secondary text under the label. */
+    description?: string;
+    size?: 'sm' | 'md' | 'lg';
+    id?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ indicator: 'text-black' }`. */
+    ui?: {
+        wrapper?: string;
+        root?: string;
+        indicator?: string;
+        content?: string;
+        label?: string;
+        description?: string;
+    };
+}
+declare var __VLS_13: {}, __VLS_31: {}, __VLS_33: {}, __VLS_48: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+} & {
+    label?: (props: typeof __VLS_31) => any;
+} & {
+    description?: (props: typeof __VLS_33) => any;
+} & {
+    default?: (props: typeof __VLS_48) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<CheckboxProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean | "indeterminate") => any;
+}, string, import("vue").PublicProps, Readonly<CheckboxProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean | "indeterminate") => any) | undefined;
+}>, {
+    unstyled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Checkbox.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,79 @@
+import { useIryxUiConfig as e } from "../config.js";
+import { checkboxTheme as t } from "../theme/checkbox.js";
+import { computed as n, createBlock as r, createCommentVNode as i, createElementBlock as a, createElementVNode as o, createTextVNode as s, createVNode as c, defineComponent as l, mergeProps as u, normalizeClass as d, openBlock as f, renderSlot as p, toDisplayString as m, unref as h, withCtx as g } from "vue";
+import { Check as _, Minus as v } from "lucide-vue-next";
+import { CheckboxIndicator as y, CheckboxRoot as b, Label as x, useForwardPropsEmits as S, useId as C } from "reka-ui";
+//#region src/components/Checkbox.vue?vue&type=script&setup=true&lang.ts
+var w = ["id"], T = /*@__PURE__*/ l({
+	__name: "Checkbox",
+	props: {
+		label: {},
+		description: {},
+		size: {},
+		id: {},
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {},
+		ui: {},
+		defaultValue: {},
+		modelValue: {},
+		disabled: { type: Boolean },
+		value: {},
+		trueValue: {},
+		falseValue: {},
+		asChild: { type: Boolean },
+		as: {},
+		name: {},
+		required: { type: Boolean }
+	},
+	emits: ["update:modelValue"],
+	setup(l, { emit: T }) {
+		let E = l, D = T, O = S(n(() => {
+			let { label: e, description: t, size: n, id: r, unstyled: i, class: a, ui: o, ...s } = E;
+			return s;
+		}), D), k = C(), A = n(() => E.id ?? k), j = n(() => !!(E.label || E.description)), M = e(), N = n(() => E.unstyled ?? M.unstyled), P = n(() => t({
+			size: E.size,
+			withText: j.value
+		})), F = n(() => N.value ? E.ui?.wrapper : P.value.wrapper({ class: E.ui?.wrapper })), I = n(() => N.value ? [E.ui?.root, E.class] : P.value.root({ class: [E.ui?.root, E.class] })), L = n(() => N.value ? E.ui?.indicator : P.value.indicator({ class: E.ui?.indicator })), R = n(() => N.value ? E.ui?.content : P.value.content({ class: E.ui?.content })), z = n(() => N.value ? E.ui?.label : P.value.label({ class: E.ui?.label })), B = n(() => N.value ? E.ui?.description : P.value.description({ class: E.ui?.description }));
+		return (e, t) => j.value ? (f(), a("div", {
+			key: 0,
+			class: d(F.value)
+		}, [c(h(b), u({ id: A.value }, h(O), {
+			"aria-describedby": E.description ? `${A.value}-description` : void 0,
+			class: I.value
+		}), {
+			default: g(() => [c(h(y), { class: d(L.value) }, {
+				default: g(() => [p(e.$slots, "default", {}, () => [E.modelValue === "indeterminate" ? (f(), r(h(v), { key: 0 })) : (f(), r(h(_), { key: 1 }))])]),
+				_: 3
+			}, 8, ["class"])]),
+			_: 3
+		}, 16, [
+			"id",
+			"aria-describedby",
+			"class"
+		]), o("div", { class: d(R.value) }, [c(h(x), {
+			for: A.value,
+			class: d(z.value)
+		}, {
+			default: g(() => [p(e.$slots, "label", {}, () => [s(m(E.label), 1)])]),
+			_: 3
+		}, 8, ["for", "class"]), E.description || e.$slots.description ? (f(), a("p", {
+			key: 0,
+			id: `${A.value}-description`,
+			class: d(B.value)
+		}, [p(e.$slots, "description", {}, () => [s(m(E.description), 1)])], 10, w)) : i("", !0)], 2)], 2)) : (f(), r(h(b), u({
+			key: 1,
+			id: E.id
+		}, h(O), { class: I.value }), {
+			default: g(() => [c(h(y), { class: d(L.value) }, {
+				default: g(() => [p(e.$slots, "default", {}, () => [E.modelValue === "indeterminate" ? (f(), r(h(v), { key: 0 })) : (f(), r(h(_), { key: 1 }))])]),
+				_: 3
+			}, 8, ["class"])]),
+			_: 3
+		}, 16, ["id", "class"]));
+	}
+});
+//#endregion
+export { T as default };

package/dist/components/Form.js

@@ -0,0 +1,5 @@
+import e from "./Form.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/Form.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/Form.vue.d.ts

@@ -0,0 +1,54 @@
+import type { FormError, FormSubmitEvent, FormValidateOn, StandardSchemaLike } from '../composables/form';
+export interface FormProps<S extends Record<string, any>> {
+    /** Reactive object holding the field values. */
+    state: S;
+    /** Any Standard Schema validator (Zod 3.24+, Valibot, ArkType…). */
+    schema?: StandardSchemaLike;
+    /** Custom validation, run after the schema. Return the errors you found. */
+    validate?: (state: S) => FormError[] | Promise<FormError[]>;
+    /** Which interactions re-validate a field. Submit always validates everything. */
+    validateOn?: FormValidateOn[];
+    disabled?: boolean;
+    class?: string;
+}
+declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<FormProps<T> & {
+        onSubmit?: ((event: FormSubmitEvent<T>) => any) | undefined;
+        onError?: ((errors: FormError[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        validate: (options?: {
+            silent?: boolean;
+        }) => Promise<T | false>;
+        clear: (name?: string) => void;
+        setErrors: (next: FormError[]) => void;
+        errors: import("vue").Ref<{
+            name?: string | undefined;
+            message: string;
+        }[], FormError[] | {
+            name?: string | undefined;
+            message: string;
+        }[]>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            errors: {
+                name?: string | undefined;
+                message: string;
+            }[];
+        }) => any;
+    };
+    emit: ((evt: "submit", event: FormSubmitEvent<T>) => void) & ((evt: "error", errors: FormError[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/Form.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,79 @@
+import { formContextKey as e, isStandardSchema as t, issuePath as n } from "../composables/form.js";
+import { computed as r, createElementBlock as i, defineComponent as a, normalizeClass as o, openBlock as s, provide as c, ref as l, renderSlot as u } from "vue";
+//#region src/components/Form.vue?vue&type=script&setup=true&lang.ts
+var d = /*@__PURE__*/ a({
+	__name: "Form",
+	props: {
+		state: {},
+		schema: {},
+		validate: {},
+		validateOn: { default: () => ["blur", "change"] },
+		disabled: { type: Boolean },
+		class: {}
+	},
+	emits: ["submit", "error"],
+	setup(a, { expose: d, emit: f }) {
+		let p = a, m = f, h = l([]);
+		async function g() {
+			let e = [];
+			if (p.schema && t(p.schema)) {
+				let t = await p.schema["~standard"].validate(p.state);
+				if (t.issues) for (let r of t.issues) e.push({
+					name: n(r),
+					message: r.message
+				});
+			}
+			return p.validate && e.push(...await p.validate(p.state)), e;
+		}
+		async function _(e = {}) {
+			let t = await g();
+			return e.silent || (h.value = t), t.length ? !1 : p.state;
+		}
+		async function v(e) {
+			let t = await g();
+			h.value = [...h.value.filter((t) => t.name !== e), ...t.filter((t) => t.name === e)];
+		}
+		function y(e) {
+			h.value = e ? h.value.filter((t) => t.name !== e) : [];
+		}
+		function b(e) {
+			h.value = e;
+		}
+		function x(e) {
+			if (e) return h.value.find((t) => t.name === e)?.message;
+		}
+		async function S(e) {
+			e.preventDefault();
+			let t = e.currentTarget, n = await g();
+			if (h.value = n, n.length) {
+				m("error", n);
+				let e = n.find((e) => e.name)?.name;
+				if (e && t) {
+					let n = `[data-iryx-field="${CSS.escape(e)}"] :is(input,textarea,select,button,[tabindex])`;
+					t.querySelector(n)?.focus();
+				}
+				return;
+			}
+			m("submit", { data: p.state });
+		}
+		return c(e, {
+			errors: h,
+			validateOn: r(() => p.validateOn),
+			disabled: r(() => p.disabled ?? !1),
+			state: r(() => p.state),
+			errorFor: x,
+			validateField: v
+		}), d({
+			validate: _,
+			clear: y,
+			setErrors: b,
+			errors: h
+		}), (e, t) => (s(), i("form", {
+			novalidate: "",
+			class: o(p.class),
+			onSubmit: S
+		}, [u(e.$slots, "default", { errors: h.value })], 34));
+	}
+});
+//#endregion
+export { d as default };

package/dist/components/FormField.js

@@ -0,0 +1,5 @@
+import e from "./FormField.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/FormField.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/FormField.vue.d.ts

@@ -0,0 +1,46 @@
+export interface FormFieldProps {
+    /** Dot-path into the form state. Links this field to its validation errors. */
+    name?: string;
+    label?: string;
+    /** Muted text under the label, explaining the field. */
+    description?: string;
+    /** Muted text on the right of the label, e.g. "Optional". */
+    hint?: string;
+    /** Muted text under the control, shown while there's no error. */
+    help?: string;
+    required?: boolean;
+    /** Force an error message, bypassing the form's validation. */
+    error?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    ui?: {
+        root?: string;
+        header?: string;
+        label?: string;
+        hint?: string;
+        description?: string;
+        error?: string;
+        help?: string;
+    };
+}
+declare var __VLS_7: {}, __VLS_9: {
+    id: string;
+    error: string | undefined;
+};
+type __VLS_Slots = {} & {
+    hint?: (props: typeof __VLS_7) => any;
+} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<FormFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormFieldProps> & Readonly<{}>, {
+    unstyled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/FormField.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,93 @@
+import { useIryxUiConfig as e } from "../config.js";
+import { formFieldContextKey as t, getByPath as n, useForm as r } from "../composables/form.js";
+import { formFieldTheme as i } from "../theme/form.js";
+import a from "./Label.js";
+import { computed as o, createBlock as s, createCommentVNode as c, createElementBlock as l, createTextVNode as u, defineComponent as d, normalizeClass as f, openBlock as p, provide as m, renderSlot as h, toDisplayString as g, unref as _, watch as v, withCtx as y } from "vue";
+import { useId as b } from "reka-ui";
+//#region src/components/FormField.vue?vue&type=script&setup=true&lang.ts
+var x = ["data-iryx-field"], S = ["id"], C = ["id"], w = ["id"], T = /*@__PURE__*/ d({
+	__name: "FormField",
+	props: {
+		name: {},
+		label: {},
+		description: {},
+		hint: {},
+		help: {},
+		required: { type: Boolean },
+		error: {},
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {},
+		ui: {}
+	},
+	setup(d) {
+		let T = d, E = r(), D = b(), O = o(() => T.error ?? E?.errorFor(T.name)), k = o(() => {
+			let e = [];
+			return T.description && e.push(`${D}-description`), O.value ? e.push(`${D}-error`) : T.help && e.push(`${D}-help`), e.length ? e.join(" ") : void 0;
+		});
+		v(() => T.name && E ? n(E.state.value, T.name) : void 0, () => {
+			if (!T.name || !E) return;
+			let e = E.validateOn.value;
+			(e.includes("change") || e.includes("input")) && E.validateField(T.name);
+		});
+		function A() {
+			!T.name || !E || E.validateOn.value.includes("blur") && E.validateField(T.name);
+		}
+		let j = e(), M = o(() => T.unstyled ?? j.unstyled), N = i();
+		function P(e, t) {
+			return M.value ? t : N[e]({ class: t });
+		}
+		return m(t, {
+			id: o(() => D),
+			name: o(() => T.name),
+			invalid: o(() => !!O.value),
+			describedBy: k
+		}), (e, t) => (p(), l("div", {
+			"data-iryx-field": T.name,
+			class: f(M.value ? T.class : _(N).root({ class: [T.ui?.root, T.class] })),
+			onFocusout: A
+		}, [
+			T.label || T.hint || e.$slots.hint ? (p(), l("div", {
+				key: 0,
+				class: f(P("header", T.ui?.header))
+			}, [T.label ? (p(), s(a, {
+				key: 0,
+				for: _(D),
+				required: T.required,
+				class: f(T.ui?.label)
+			}, {
+				default: y(() => [u(g(T.label), 1)]),
+				_: 1
+			}, 8, [
+				"for",
+				"required",
+				"class"
+			])) : c("", !0), T.hint || e.$slots.hint ? (p(), l("span", {
+				key: 1,
+				class: f(P("hint", T.ui?.hint))
+			}, [h(e.$slots, "hint", {}, () => [u(g(T.hint), 1)])], 2)) : c("", !0)], 2)) : c("", !0),
+			T.description ? (p(), l("p", {
+				key: 1,
+				id: `${_(D)}-description`,
+				class: f(P("description", T.ui?.description))
+			}, g(T.description), 11, S)) : c("", !0),
+			h(e.$slots, "default", {
+				id: _(D),
+				error: O.value
+			}),
+			O.value ? (p(), l("p", {
+				key: 2,
+				id: `${_(D)}-error`,
+				class: f(P("error", T.ui?.error))
+			}, g(O.value), 11, C)) : T.help ? (p(), l("p", {
+				key: 3,
+				id: `${_(D)}-help`,
+				class: f(P("help", T.ui?.help))
+			}, g(T.help), 11, w)) : c("", !0)
+		], 42, x));
+	}
+});
+//#endregion
+export { T as default };

package/dist/components/Input.js

@@ -0,0 +1,5 @@
+import e from "./Input.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/Input.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/Input.vue.d.ts

@@ -0,0 +1,29 @@
+export interface InputProps {
+    type?: string;
+    size?: 'sm' | 'md' | 'lg';
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    /** Mark the field as invalid — styles the border and ring red. */
+    invalid?: boolean;
+    id?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+}
+type __VLS_Props = InputProps;
+type __VLS_ModelProps = {
+    modelValue?: string | number | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number | null | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    type: string;
+    invalid: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,57 @@
+import { useIryxUiConfig as e } from "../config.js";
+import { useFormField as t } from "../composables/form.js";
+import { inputTheme as n } from "../theme/input.js";
+import { computed as r, createElementBlock as i, defineComponent as a, mergeModels as o, normalizeClass as s, openBlock as c, unref as l, useModel as u, vModelDynamic as d, withDirectives as f } from "vue";
+//#region src/components/Input.vue?vue&type=script&setup=true&lang.ts
+var p = [
+	"id",
+	"type",
+	"placeholder",
+	"disabled",
+	"required",
+	"aria-invalid",
+	"aria-describedby"
+], m = /*@__PURE__*/ a({
+	__name: "Input",
+	props: /*@__PURE__*/ o({
+		type: { default: "text" },
+		size: {},
+		placeholder: {},
+		disabled: { type: Boolean },
+		required: { type: Boolean },
+		invalid: {
+			type: Boolean,
+			default: void 0
+		},
+		id: {},
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {}
+	}, {
+		modelValue: {},
+		modelModifiers: {}
+	}),
+	emits: ["update:modelValue"],
+	setup(a) {
+		let o = a, m = u(a, "modelValue"), h = t(), g = r(() => o.id ?? h?.id.value), _ = r(() => o.invalid ?? h?.invalid.value ?? !1), v = e(), y = r(() => o.unstyled ?? v.unstyled), b = r(() => y.value ? o.class : n({
+			size: o.size,
+			invalid: _.value,
+			class: o.class
+		}));
+		return (e, t) => f((c(), i("input", {
+			id: g.value,
+			"onUpdate:modelValue": t[0] ||= (e) => m.value = e,
+			type: o.type,
+			placeholder: o.placeholder,
+			disabled: o.disabled,
+			required: o.required,
+			"aria-invalid": _.value || void 0,
+			"aria-describedby": l(h)?.describedBy.value,
+			class: s(b.value)
+		}, null, 10, p)), [[d, m.value]]);
+	}
+});
+//#endregion
+export { m as default };

package/dist/components/Label.js

@@ -0,0 +1,5 @@
+import e from "./Label.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/Label.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/Label.vue.d.ts

@@ -0,0 +1,23 @@
+import type { LabelProps as RekaLabelProps } from 'reka-ui';
+export interface LabelProps extends RekaLabelProps {
+    /** Append a red asterisk to mark the associated field as required. */
+    required?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<LabelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LabelProps> & Readonly<{}>, {
+    unstyled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Label.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,41 @@
+import { useIryxUiConfig as e } from "../config.js";
+import { labelTheme as t } from "../theme/label.js";
+import { computed as n, createBlock as r, defineComponent as i, normalizeClass as a, openBlock as o, renderSlot as s, unref as c, withCtx as l } from "vue";
+import { Label as u } from "reka-ui";
+//#region src/components/Label.vue?vue&type=script&setup=true&lang.ts
+var d = /*@__PURE__*/ i({
+	__name: "Label",
+	props: {
+		required: { type: Boolean },
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {},
+		for: {},
+		asChild: { type: Boolean },
+		as: {}
+	},
+	setup(i) {
+		let d = i, f = e(), p = n(() => d.unstyled ?? f.unstyled), m = n(() => p.value ? d.class : t({
+			required: d.required,
+			class: d.class
+		}));
+		return (e, t) => (o(), r(c(u), {
+			for: d.for,
+			as: d.as,
+			"as-child": d.asChild,
+			class: a(m.value)
+		}, {
+			default: l(() => [s(e.$slots, "default")]),
+			_: 3
+		}, 8, [
+			"for",
+			"as",
+			"as-child",
+			"class"
+		]));
+	}
+});
+//#endregion
+export { d as default };

package/dist/components/RadioGroup.js

@@ -0,0 +1,5 @@
+import e from "./RadioGroup.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/RadioGroup.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/RadioGroup.vue.d.ts

@@ -0,0 +1,41 @@
+import type { RadioGroupRootProps } from 'reka-ui';
+export interface RadioGroupItemOption {
+    label: string;
+    value: string;
+    /** Secondary text under the label. */
+    description?: string;
+    disabled?: boolean;
+}
+export interface RadioGroupProps extends RadioGroupRootProps {
+    /** Options to render. Strings are expanded to `{ label, value }`. */
+    items?: (RadioGroupItemOption | string)[];
+    size?: 'sm' | 'md' | 'lg';
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    ui?: {
+        root?: string;
+        item?: string;
+        label?: string;
+        description?: string;
+    };
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<RadioGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (payload: import("reka-ui").AcceptableValue) => any;
+}, string, import("vue").PublicProps, Readonly<RadioGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableValue) => any) | undefined;
+}>, {
+    unstyled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};