iryx-ui 0.12.0 → 0.13.0

package/dist/components/TagsInput.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,119 @@
+import { useIryxUiConfig as e } from "../config.js";
+import t from "./Icon.js";
+import { useFormField as n } from "../composables/form.js";
+import { tagsInputTheme as r } from "../theme/tags-input.js";
+import { Fragment as i, computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, createVNode as l, defineComponent as u, mergeProps as d, normalizeClass as f, openBlock as p, renderList as m, renderSlot as h, unref as g, withCtx as _ } from "vue";
+import { Cancel01Icon as v } from "@hugeicons/core-free-icons";
+import { TagsInputClear as y, TagsInputInput as b, TagsInputItem as x, TagsInputItemDelete as S, TagsInputItemText as C, TagsInputRoot as w } from "reka-ui";
+//#region src/components/TagsInput.vue?vue&type=script&setup=true&lang.ts
+var T = /*@__PURE__*/ u({
+	inheritAttrs: !1,
+	__name: "TagsInput",
+	props: {
+		modelValue: {},
+		placeholder: {},
+		max: {},
+		delimiter: { default: "," },
+		duplicate: { type: Boolean },
+		addOnPaste: { type: Boolean },
+		addOnTab: { type: Boolean },
+		addOnBlur: { type: Boolean },
+		clearable: { type: Boolean },
+		disabled: { type: Boolean },
+		invalid: {
+			type: Boolean,
+			default: void 0
+		},
+		size: {},
+		id: {},
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {},
+		ui: {}
+	},
+	emits: [
+		"update:modelValue",
+		"invalidTag",
+		"addTag",
+		"removeTag"
+	],
+	setup(u, { emit: T }) {
+		let E = u, D = T, O = a(() => E.modelValue ?? []), k = a(() => E.max !== void 0 && O.value.length >= E.max), A = n(), j = a(() => E.id ?? A?.id.value), M = a(() => E.invalid ?? A?.invalid.value ?? !1), N = e(), P = a(() => E.unstyled ?? N.unstyled), F = a(() => r({
+			size: E.size,
+			invalid: M.value
+		}));
+		function I(e, t) {
+			let n = [E.ui?.[e], t];
+			return P.value ? n : F.value[e]({ class: n });
+		}
+		return (e, n) => (p(), o(g(w), {
+			"model-value": O.value,
+			max: E.max,
+			delimiter: E.delimiter,
+			duplicate: E.duplicate,
+			"add-on-paste": E.addOnPaste,
+			"add-on-tab": E.addOnTab,
+			"add-on-blur": E.addOnBlur,
+			disabled: E.disabled,
+			class: f(I("root", E.class)),
+			"onUpdate:modelValue": n[0] ||= (e) => D("update:modelValue", e),
+			onInvalid: n[1] ||= (e) => D("invalidTag", String(e)),
+			onAddTag: n[2] ||= (e) => D("addTag", String(e)),
+			onRemoveTag: n[3] ||= (e) => D("removeTag", String(e))
+		}, {
+			default: _(() => [
+				(p(!0), c(i, null, m(O.value, (n) => (p(), o(g(x), {
+					key: n,
+					value: n,
+					class: f(I("tag"))
+				}, {
+					default: _(() => [h(e.$slots, "tag", { tag: n }, () => [l(g(C), { class: f(I("tagText")) }, null, 8, ["class"]), l(g(S), {
+						"aria-label": `Remove ${n}`,
+						class: f(I("tagDelete"))
+					}, {
+						default: _(() => [l(t, { icon: g(v) }, null, 8, ["icon"])]),
+						_: 1
+					}, 8, ["aria-label", "class"])])]),
+					_: 2
+				}, 1032, ["value", "class"]))), 128)),
+				l(g(b), d({
+					id: j.value,
+					placeholder: k.value ? void 0 : E.placeholder,
+					readonly: k.value || void 0,
+					"aria-invalid": M.value || void 0,
+					"aria-describedby": g(A)?.describedBy.value
+				}, e.$attrs, { class: I("input") }), null, 16, [
+					"id",
+					"placeholder",
+					"readonly",
+					"aria-invalid",
+					"aria-describedby",
+					"class"
+				]),
+				E.clearable && O.value.length ? (p(), o(g(y), {
+					key: 0,
+					"aria-label": "Clear all",
+					class: f(I("clear"))
+				}, {
+					default: _(() => [h(e.$slots, "clear", {}, () => [l(t, { icon: g(v) }, null, 8, ["icon"])])]),
+					_: 3
+				}, 8, ["class"])) : s("", !0)
+			]),
+			_: 3
+		}, 8, [
+			"model-value",
+			"max",
+			"delimiter",
+			"duplicate",
+			"add-on-paste",
+			"add-on-tab",
+			"add-on-blur",
+			"disabled",
+			"class"
+		]));
+	}
+});
+//#endregion
+export { T as default };

package/dist/components/Textarea.vue_vue_type_script_setup_true_lang.js

@@ -1,6 +1,6 @@
 import { useIryxUiConfig as e } from "../config.js";
-import { useFormField as t } from "../composables/form.js";
-import { textareaTheme as n } from "../theme/input.js";
+import { textareaTheme as t } from "../theme/input.js";
+import { useFormField as n } from "../composables/form.js";
 import { computed as r, createElementBlock as i, defineComponent as a, mergeModels as o, nextTick as s, normalizeClass as c, onMounted as l, openBlock as u, ref as d, unref as f, useModel as p, vModelText as m, watch as h, withDirectives as g } from "vue";
 //#region src/components/Textarea.vue?vue&type=script&setup=true&lang.ts
 var _ = [
@@ -36,7 +36,7 @@ var _ = [
 	}),
 	emits: ["update:modelValue"],
 	setup(a, { expose: o }) {
-		let v = a, y = p(a, "modelValue"), b = t(), x = r(() => v.id ?? b?.id.value), S = r(() => v.invalid ?? b?.invalid.value ?? !1), C = e(), w = r(() => v.unstyled ?? C.unstyled), T = r(() => w.value ? v.class : n({
+		let v = a, y = p(a, "modelValue"), b = n(), x = r(() => v.id ?? b?.id.value), S = r(() => v.invalid ?? b?.invalid.value ?? !1), C = e(), w = r(() => v.unstyled ?? C.unstyled), T = r(() => w.value ? v.class : t({
 			size: v.size,
 			invalid: S.value,
 			autosize: !!v.autosize,

package/dist/components/TimeField.js

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

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

@@ -0,0 +1,50 @@
+export interface TimeFieldProps {
+    /**
+     * The time as a `HH:mm` (or `HH:mm:ss`) **string** on a 24-hour clock,
+     * never a `Date`. A `Date` carries a date and a time zone nobody asked for,
+     * and "half past nine" is neither. Padded so it sorts as a string.
+     */
+    modelValue?: string | null;
+    /** How much of the time to show. `second` adds a seconds segment. */
+    granularity?: 'hour' | 'minute' | 'second';
+    /**
+     * 12- or 24-hour display. Left unset it follows `locale`, which is the
+     * right default — this is a display choice, not a data one; the model
+     * stays 24-hour either way.
+     */
+    hourCycle?: 12 | 24;
+    locale?: string;
+    /** Stepping interval per segment, for arrow keys and scrolling. */
+    step?: {
+        hour?: number;
+        minute?: number;
+        second?: number;
+    };
+    /** Earliest and latest allowed, in the same `HH:mm` form. */
+    minValue?: string;
+    maxValue?: string;
+    size?: 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+    readonly?: boolean;
+    invalid?: boolean;
+    id?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ segment: 'px-1' }`. */
+    ui?: {
+        root?: string;
+        segment?: string;
+        literal?: string;
+    };
+}
+declare const __VLS_export: import("vue").DefineComponent<TimeFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<TimeFieldProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    invalid: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/TimeField.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,85 @@
+import { useIryxUiConfig as e } from "../config.js";
+import { useFormField as t } from "../composables/form.js";
+import { toIsoTime as n, toTime as r } from "../composables/date.js";
+import { timeFieldTheme as i } from "../theme/time-field.js";
+import { Fragment as a, computed as o, createBlock as s, createElementBlock as c, createTextVNode as l, defineComponent as u, normalizeClass as d, openBlock as f, renderList as p, toDisplayString as m, unref as h, withCtx as g } from "vue";
+import { TimeFieldInput as _, TimeFieldRoot as v } from "reka-ui";
+//#region src/components/TimeField.vue?vue&type=script&setup=true&lang.ts
+var y = /*@__PURE__*/ u({
+	__name: "TimeField",
+	props: {
+		modelValue: {},
+		granularity: {},
+		hourCycle: {},
+		locale: {},
+		step: {},
+		minValue: {},
+		maxValue: {},
+		size: {},
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		invalid: {
+			type: Boolean,
+			default: void 0
+		},
+		id: {},
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {},
+		ui: {}
+	},
+	emits: ["update:modelValue"],
+	setup(u, { emit: y }) {
+		let b = u, x = y, S = t(), C = o(() => b.id ?? S?.id.value), w = o(() => b.invalid ?? S?.invalid.value ?? !1), T = e(), E = o(() => b.unstyled ?? T.unstyled), D = o(() => i({
+			size: b.size,
+			invalid: w.value
+		})), O = o(() => E.value ? [b.ui?.root, b.class] : D.value.root({ class: [b.ui?.root, b.class] })), k = o(() => E.value ? b.ui?.segment : D.value.segment({ class: b.ui?.segment })), A = o(() => E.value ? b.ui?.literal : D.value.literal({ class: b.ui?.literal }));
+		return (e, t) => (f(), s(h(v), {
+			id: C.value,
+			"model-value": h(r)(b.modelValue),
+			granularity: b.granularity,
+			"hour-cycle": b.hourCycle,
+			locale: b.locale,
+			step: b.step,
+			"min-value": h(r)(b.minValue),
+			"max-value": h(r)(b.maxValue),
+			disabled: b.disabled,
+			readonly: b.readonly,
+			"aria-invalid": w.value || void 0,
+			"aria-describedby": h(S)?.describedBy.value,
+			class: d(O.value),
+			"onUpdate:modelValue": t[0] ||= (e) => x("update:modelValue", h(n)(e))
+		}, {
+			default: g(({ segments: e }) => [(f(!0), c(a, null, p(e, (e) => (f(), c(a, { key: e.part }, [e.part === "literal" ? (f(), c("span", {
+				key: 0,
+				class: d(A.value)
+			}, m(e.value), 3)) : (f(), s(h(_), {
+				key: 1,
+				part: e.part,
+				class: d(k.value)
+			}, {
+				default: g(() => [l(m(e.value), 1)]),
+				_: 2
+			}, 1032, ["part", "class"]))], 64))), 128))]),
+			_: 1
+		}, 8, [
+			"id",
+			"model-value",
+			"granularity",
+			"hour-cycle",
+			"locale",
+			"step",
+			"min-value",
+			"max-value",
+			"disabled",
+			"readonly",
+			"aria-invalid",
+			"aria-describedby",
+			"class"
+		]));
+	}
+});
+//#endregion
+export { y as default };

package/dist/components/Timeline.js

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

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

@@ -0,0 +1,61 @@
+import type { IconLike } from '../composables/icon';
+export type TimelineVariant = 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+export interface TimelineItem {
+    /** What happened. Say it in the title — colour alone carries nothing. */
+    title: string;
+    description?: string;
+    /**
+     * When it happened. Rendered as given, so format it where you know the
+     * reader's locale rather than guessing here.
+     */
+    time?: string;
+    /** Machine-readable timestamp for the `<time>` element, e.g. an ISO string. */
+    datetime?: string;
+    icon?: IconLike;
+    variant?: TimelineVariant;
+}
+export interface TimelineProps {
+    items?: TimelineItem[];
+    size?: 'sm' | 'md';
+    /** Applied to any item that does not set its own. */
+    variant?: TimelineVariant;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ title: 'text-base' }`. */
+    ui?: {
+        root?: string;
+        item?: string;
+        rail?: string;
+        marker?: string;
+        line?: string;
+        content?: string;
+        header?: string;
+        title?: string;
+        time?: string;
+        description?: string;
+    };
+}
+declare var __VLS_1: {
+    item: TimelineItem;
+    index: number;
+}, __VLS_8: {
+    item: TimelineItem;
+    index: number;
+};
+type __VLS_Slots = {} & {
+    marker?: (props: typeof __VLS_1) => any;
+} & {
+    item?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<TimelineProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TimelineProps> & 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/Timeline.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,60 @@
+import { useIryxUiConfig as e } from "../config.js";
+import t from "./Icon.js";
+import { timelineTheme as n } from "../theme/timeline.js";
+import { Fragment as r, computed as i, createBlock as a, createCommentVNode as o, createElementBlock as s, createElementVNode as c, defineComponent as l, normalizeClass as u, openBlock as d, renderList as f, renderSlot as p, toDisplayString as m } from "vue";
+//#region src/components/Timeline.vue?vue&type=script&setup=true&lang.ts
+var h = ["datetime"], g = /*@__PURE__*/ l({
+	__name: "Timeline",
+	props: {
+		items: {},
+		size: {},
+		variant: {},
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {},
+		ui: {}
+	},
+	setup(l) {
+		let g = l, _ = i(() => g.items ?? []), v = e(), y = i(() => g.unstyled ?? v.unstyled);
+		function b(e, t) {
+			return n({
+				size: g.size,
+				variant: e.variant ?? g.variant,
+				withIcon: !!e.icon,
+				last: t === _.value.length - 1
+			});
+		}
+		let x = i(() => n({ size: g.size })), S = i(() => y.value ? [g.ui?.root, g.class] : x.value.root({ class: [g.ui?.root, g.class] }));
+		function C(e, t, n) {
+			let r = g.ui?.[n];
+			return y.value ? r : b(e, t)[n]({ class: r });
+		}
+		return (e, n) => (d(), s("ol", { class: u(S.value) }, [(d(!0), s(r, null, f(_.value, (n, r) => (d(), s("li", {
+			key: r,
+			class: u(y.value ? g.ui?.item : x.value.item({ class: g.ui?.item }))
+		}, [c("div", { class: u(y.value ? g.ui?.rail : x.value.rail({ class: g.ui?.rail })) }, [c("span", { class: u(C(n, r, "marker")) }, [p(e.$slots, "marker", {
+			item: n,
+			index: r
+		}, () => [n.icon ? (d(), a(t, {
+			key: 0,
+			icon: n.icon
+		}, null, 8, ["icon"])) : o("", !0)])], 2), r === _.value.length - 1 ? o("", !0) : (d(), s("span", {
+			key: 0,
+			class: u(y.value ? g.ui?.line : x.value.line({ class: g.ui?.line }))
+		}, null, 2))], 2), c("div", { class: u(C(n, r, "content")) }, [p(e.$slots, "item", {
+			item: n,
+			index: r
+		}, () => [c("div", { class: u(C(n, r, "header")) }, [c("span", { class: u(C(n, r, "title")) }, m(n.title), 3), n.time ? (d(), s("time", {
+			key: 0,
+			datetime: n.datetime,
+			class: u(C(n, r, "time"))
+		}, m(n.time), 11, h)) : o("", !0)], 2), n.description ? (d(), s("p", {
+			key: 0,
+			class: u(C(n, r, "description"))
+		}, m(n.description), 3)) : o("", !0)])], 2)], 2))), 128))], 2));
+	}
+});
+//#endregion
+export { g as default };

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

@@ -20,8 +20,8 @@ export interface ToasterProps {
     };
 }
 declare const __VLS_export: import("vue").DefineComponent<ToasterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ToasterProps> & Readonly<{}>, {
-    closeLabel: string;
     unstyled: boolean;
+    closeLabel: string;
     duration: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/components/Toggle.js

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

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

@@ -0,0 +1,42 @@
+export interface ToggleProps {
+    /** Pressed or not. Two-way via `v-model`. */
+    modelValue?: boolean | null;
+    /** Starting state when you are not controlling it. */
+    defaultValue?: boolean;
+    disabled?: boolean;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /**
+     * Square the toggle for icon-only use, dropping the horizontal padding.
+     * An icon-only control has no text to name it, so pass an `aria-label`.
+     *
+     * For an icon *beside* a label, mark the icon with
+     * `data-icon="inline-start"` or `data-icon="inline-end"` instead — the
+     * padding then tightens on that side, exactly as it does on `IButton`.
+     */
+    square?: boolean;
+    /** Stretch to the full width of the container. */
+    block?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+}
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ToggleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ToggleProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    modelValue: boolean | null;
+}, {}, {}, {}, 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/Toggle.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,52 @@
+import { useIryxUiConfig as e } from "../config.js";
+import { toggleTheme as t } from "../theme/toggle.js";
+import { computed as n, createBlock as r, defineComponent as i, mergeProps as a, openBlock as o, renderSlot as s, unref as c, withCtx as l } from "vue";
+import { Toggle as u } from "reka-ui";
+//#region src/components/Toggle.vue?vue&type=script&setup=true&lang.ts
+var d = /*@__PURE__*/ i({
+	inheritAttrs: !1,
+	__name: "Toggle",
+	props: {
+		modelValue: {
+			type: [Boolean, null],
+			default: void 0
+		},
+		defaultValue: { type: Boolean },
+		disabled: { type: Boolean },
+		size: {},
+		square: { type: Boolean },
+		block: { type: Boolean },
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {}
+	},
+	emits: ["update:modelValue"],
+	setup(i, { emit: d }) {
+		let f = i, p = d, m = e(), h = n(() => f.unstyled ?? m.unstyled), g = n(() => h.value ? f.class : t({
+			size: f.size,
+			square: f.square,
+			block: f.block,
+			class: f.class
+		}));
+		return (e, t) => (o(), r(c(u), a({
+			"model-value": f.modelValue,
+			"default-value": f.defaultValue,
+			disabled: f.disabled
+		}, e.$attrs, {
+			class: g.value,
+			"onUpdate:modelValue": t[0] ||= (e) => p("update:modelValue", e)
+		}), {
+			default: l(() => [s(e.$slots, "default")]),
+			_: 3
+		}, 16, [
+			"model-value",
+			"default-value",
+			"disabled",
+			"class"
+		]));
+	}
+});
+//#endregion
+export { d as default };

package/dist/components/ToggleGroup.js

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

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

@@ -0,0 +1,64 @@
+import type { IconLike } from '../composables/icon';
+import type { ToggleGroupVariant } from '../theme/toggle';
+export interface ToggleGroupItemOption {
+    label: string;
+    /** Identifies the item. Defaults to the label. */
+    value?: string;
+    icon?: IconLike;
+    disabled?: boolean;
+    /**
+     * Names the item when `iconOnly` hides its label. Without one, an icon-only
+     * item reaches a screen reader as an unnamed button.
+     */
+    ariaLabel?: string;
+}
+export interface ToggleGroupProps {
+    items?: (ToggleGroupItemOption | string)[];
+    /**
+     * `single` behaves like a segmented control — one item on at a time, and
+     * the model is that item's value. `multiple` lets any number be on, and the
+     * model is an array.
+     */
+    type?: 'single' | 'multiple';
+    modelValue?: string | string[];
+    variant?: ToggleGroupVariant;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    orientation?: 'horizontal' | 'vertical';
+    /** Hide the labels and square the items, leaving only the icons. */
+    iconOnly?: boolean;
+    /** Stretch to fill the container, splitting the width between items. */
+    block?: boolean;
+    disabled?: boolean;
+    /** Wrap from the last item back to the first when arrowing past the end. */
+    loop?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ item: 'px-6' }`. */
+    ui?: {
+        root?: string;
+        item?: string;
+    };
+}
+declare var __VLS_16: {
+    item: ToggleGroupItemOption;
+};
+type __VLS_Slots = {} & {
+    item?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ToggleGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | string[]) => any;
+}, string, import("vue").PublicProps, Readonly<ToggleGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+}>, {
+    type: "single" | "multiple";
+    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/ToggleGroup.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,78 @@
+import { useIryxUiConfig as e } from "../config.js";
+import t from "./Icon.js";
+import { toggleGroupTheme as n, toggleTheme as r } from "../theme/toggle.js";
+import { Fragment as i, computed as a, createBlock as o, createCommentVNode as s, createElementBlock as c, defineComponent as l, normalizeClass as u, openBlock as d, renderList as f, renderSlot as p, toDisplayString as m, unref as h, withCtx as g } from "vue";
+import { ToggleGroupItem as _, ToggleGroupRoot as v } from "reka-ui";
+//#region src/components/ToggleGroup.vue?vue&type=script&setup=true&lang.ts
+var y = { key: 1 }, b = /*@__PURE__*/ l({
+	__name: "ToggleGroup",
+	props: {
+		items: {},
+		type: { default: "single" },
+		modelValue: {},
+		variant: {},
+		size: {},
+		orientation: {},
+		iconOnly: { type: Boolean },
+		block: { type: Boolean },
+		disabled: { type: Boolean },
+		loop: { type: Boolean },
+		unstyled: {
+			type: Boolean,
+			default: void 0
+		},
+		class: {},
+		ui: {}
+	},
+	emits: ["update:modelValue"],
+	setup(l, { emit: b }) {
+		let x = l, S = b, C = a(() => (x.items ?? []).map((e) => typeof e == "string" ? { label: e } : e)), w = (e) => e.value ?? e.label, T = e(), E = a(() => x.unstyled ?? T.unstyled), D = a(() => n({
+			variant: x.variant,
+			orientation: x.orientation,
+			block: x.block
+		})), O = a(() => E.value ? [x.ui?.root, x.class] : D.value.root({ class: [x.ui?.root, x.class] })), k = a(() => E.value ? x.ui?.item : r({
+			size: x.size,
+			square: x.iconOnly,
+			class: D.value.item({ class: x.ui?.item })
+		}));
+		return (e, n) => (d(), o(h(v), {
+			type: x.type,
+			"model-value": x.modelValue,
+			disabled: x.disabled,
+			orientation: x.orientation,
+			loop: x.loop,
+			class: u(O.value),
+			"onUpdate:modelValue": n[0] ||= (e) => S("update:modelValue", e)
+		}, {
+			default: g(() => [(d(!0), c(i, null, f(C.value, (n) => (d(), o(h(_), {
+				key: w(n),
+				value: w(n),
+				disabled: n.disabled,
+				"aria-label": n.ariaLabel ?? (x.iconOnly ? n.label : void 0),
+				class: u(k.value)
+			}, {
+				default: g(() => [p(e.$slots, "item", { item: n }, () => [n.icon ? (d(), o(t, {
+					key: 0,
+					icon: n.icon,
+					"data-icon": x.iconOnly ? void 0 : "inline-start"
+				}, null, 8, ["icon", "data-icon"])) : s("", !0), x.iconOnly ? s("", !0) : (d(), c("span", y, m(n.label), 1))])]),
+				_: 2
+			}, 1032, [
+				"value",
+				"disabled",
+				"aria-label",
+				"class"
+			]))), 128))]),
+			_: 3
+		}, 8, [
+			"type",
+			"model-value",
+			"disabled",
+			"orientation",
+			"loop",
+			"class"
+		]));
+	}
+});
+//#endregion
+export { b as default };

package/dist/components/Toolbar.js

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