relationship-ux 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,42 @@
-# Temporary Holding Version
+# Relationship-UX
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This template should help get you started developing with Vue 3 in Vite.
+
+## Recommended IDE Setup
+
+[VS Code](https://code.visualstudio.com/) + [Vue (Official)](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).
+
+## Recommended Browser Setup
+
+- Chromium-based browsers (Chrome, Edge, Brave, etc.):
+  - [Vue.js devtools](https://chromewebstore.google.com/detail/vuejs-devtools/nhdogjmejiglipccpnnnanhbledajbpd)
+  - [Turn on Custom Object Formatter in Chrome DevTools](http://bit.ly/object-formatters)
+- Firefox:
+  - [Vue.js devtools](https://addons.mozilla.org/en-US/firefox/addon/vue-js-devtools/)
+  - [Turn on Custom Object Formatter in Firefox DevTools](https://fxdx.dev/firefox-devtools-custom-object-formatters/)
+
+## Type Support for `.vue` Imports in TS
+
+TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) to make the TypeScript language service aware of `.vue` types.
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vite.dev/config/).
+
+## Project Setup
+
+```sh
+npm install
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+npm run dev
+```
+
+### Type-Check, Compile and Minify for Production
+
+```sh
+npm run build
+```

package/dist/Overlay-CfZOlcSg.js

@@ -0,0 +1,413 @@
+import { cn as e, createVariants as t } from "./utils/index.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, normalizeStyle as f, onBeforeUnmount as p, openBlock as m, ref as h, renderSlot as g, resolveDynamicComponent as _, toDisplayString as v, unref as y, vShow as b, withCtx as x, withDirectives as S, withModifiers as C } from "vue";
+// src/components/interaction/window/useWindowDrag.ts
+function w(e) {
+	let t = h(!1), n = 0, r = 0, i = 0, a = 0;
+	function o(o) {
+		if (o.button !== 0) return;
+		let l = e.position();
+		n = o.clientX, r = o.clientY, i = l.x, a = l.y, t.value = !0, window.addEventListener("mousemove", s), window.addEventListener("mouseup", c);
+	}
+	function s(o) {
+		if (!t.value) return;
+		let s = o.clientX - n, c = o.clientY - r, l = e.size(), u = e.bounds(), d = Math.max(0, u.width - l.width), f = Math.max(0, u.height - l.height), p = Math.min(Math.max(i + s, 0), d), m = Math.min(Math.max(a + c, 0), f);
+		e.onMove({
+			x: p,
+			y: m
+		});
+	}
+	function c() {
+		t.value && (t.value = !1, window.removeEventListener("mousemove", s), window.removeEventListener("mouseup", c));
+	}
+	return p(c), {
+		dragging: t,
+		start: o
+	};
+}
+// src/components/interaction/window/useWindowResize.ts
+function T(e) {
+	let t = h(!1), n = null, r = 0, i = 0, a = 0, o = 0, s = 0, c = 0;
+	function l(l, f) {
+		if (l.button !== 0) return;
+		let p = e.position(), m = e.size();
+		n = f, r = l.clientX, i = l.clientY, a = p.x, o = p.y, s = m.width, c = m.height, t.value = !0, window.addEventListener("mousemove", u), window.addEventListener("mouseup", d);
+	}
+	function u(l) {
+		if (!t.value || !n) return;
+		let u = l.clientX - r, d = l.clientY - i, f = e.bounds(), p = e.minSize?.width ?? 200, m = e.minSize?.height ?? 120, h = a, g = o, _ = s, v = c;
+		if (n.includes("e") && (_ = Math.max(p, s + u), _ = Math.min(_, f.width - a)), n.includes("s") && (v = Math.max(m, c + d), v = Math.min(v, f.height - o)), n.includes("w")) {
+			let e = Math.min(u, a);
+			h = a + e, _ = s - e, _ < p && (_ = p, h = a + s - p);
+		}
+		if (n.includes("n")) {
+			let e = -o, t = c - m, n = Math.max(e, Math.min(d, t));
+			g = o + n, v = c - n;
+		}
+		h = Math.max(0, h), g = Math.max(0, g), _ = Math.min(_, f.width - h), v = Math.min(v, f.height - g), e.onResize({
+			width: _,
+			height: v
+		}, {
+			x: h,
+			y: g
+		});
+	}
+	function d() {
+		t.value && (t.value = !1, n = null, window.removeEventListener("mousemove", u), window.removeEventListener("mouseup", d));
+	}
+	return p(d), {
+		resizing: t,
+		start: l
+	};
+}
+// src/components/base/button/button.variants.ts
+var E = t({
+	base: [
+		"inline-flex",
+		"items-center",
+		"justify-center",
+		"gap-2",
+		"font-medium",
+		"select-none",
+		"transition-colors",
+		"outline-none",
+		"cursor-pointer",
+		"focus-visible:ring-2",
+		"focus-visible:ring-offset-2",
+		"focus-visible:ring-slate-500",
+		"focus-visible:ring-offset-white",
+		"dark:focus-visible:ring-slate-400",
+		"dark:focus-visible:ring-offset-slate-950",
+		"disabled:pointer-events-none",
+		"disabled:cursor-not-allowed",
+		"disabled:opacity-50"
+	],
+	variants: {
+		variant: {
+			filled: [
+				"bg-slate-900",
+				"text-white",
+				"hover:bg-slate-800",
+				"active:bg-slate-950",
+				"dark:bg-slate-100",
+				"dark:text-slate-900",
+				"dark:hover:bg-slate-200",
+				"dark:active:bg-slate-300"
+			],
+			outlined: [
+				"border",
+				"border-slate-300",
+				"bg-transparent",
+				"text-slate-900",
+				"hover:bg-slate-50",
+				"active:bg-slate-100",
+				"dark:border-slate-700",
+				"dark:text-slate-100",
+				"dark:hover:bg-slate-800",
+				"dark:active:bg-slate-700"
+			],
+			ghost: [
+				"bg-transparent",
+				"text-slate-900",
+				"hover:bg-slate-100",
+				"active:bg-slate-200",
+				"dark:text-slate-100",
+				"dark:hover:bg-slate-800",
+				"dark:active:bg-slate-700"
+			]
+		},
+		size: {
+			sm: [
+				"h-8",
+				"px-3",
+				"text-sm"
+			],
+			md: [
+				"h-10",
+				"px-4",
+				"text-sm"
+			],
+			lg: [
+				"h-12",
+				"px-6",
+				"text-base"
+			]
+		},
+		rounded: {
+			none: "rounded-none",
+			sm: "rounded-sm",
+			md: "rounded-md",
+			lg: "rounded-lg",
+			full: "rounded-full"
+		}
+	},
+	defaultVariants: {
+		variant: "filled",
+		size: "md",
+		rounded: "md"
+	}
+}), D = {
+	key: 0,
+	class: "inline-flex",
+	"aria-hidden": "true"
+}, O = /* @__PURE__ */ l({
+	inheritAttrs: !1,
+	__name: "Button",
+	props: {
+		as: { default: "button" },
+		class: {},
+		variant: {},
+		size: {},
+		rounded: {},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		loading: {
+			type: Boolean,
+			default: !1
+		},
+		type: { default: "button" }
+	},
+	setup(t) {
+		let s = t, c = n(() => e(E.compose(s), s.loading && "cursor-wait", s.class));
+		return (e, n) => (m(), r(_(t.as), u(e.$attrs, {
+			type: t.as === "button" ? t.type : void 0,
+			disabled: t.as === "button" ? t.disabled || t.loading : void 0,
+			"aria-disabled": t.disabled || t.loading,
+			"aria-busy": t.loading,
+			class: c.value
+		}), {
+			default: x(() => [t.loading ? (m(), a("span", D, [...n[0] ||= [o("svg", {
+				class: "size-4 animate-spin",
+				viewBox: "0 0 24 24",
+				fill: "none"
+			}, [o("circle", {
+				class: "opacity-25",
+				cx: "12",
+				cy: "12",
+				r: "10",
+				stroke: "currentColor",
+				"stroke-width": "4"
+			}), o("path", {
+				class: "opacity-75",
+				fill: "currentColor",
+				d: "M4 12a8 8 0 018-8v4a4 4 0 00-4 4H4z"
+			})], -1)]])) : i("", !0), g(e.$slots, "default")]),
+			_: 3
+		}, 16, [
+			"type",
+			"disabled",
+			"aria-disabled",
+			"aria-busy",
+			"class"
+		]));
+	}
+}), k = { class: "min-w-0 flex-1" }, A = { class: "truncate font-medium dark:text-slate-100" }, j = { class: "min-h-0 flex-1 overflow-auto dark:text-slate-100" }, M = {
+	key: 0,
+	class: "absolute inset-0 pointer-events-none"
+}, N = /* @__PURE__ */ l({
+	__name: "Window",
+	props: {
+		title: { default: "Window" },
+		position: {},
+		size: {},
+		zIndex: {},
+		minimized: {
+			type: Boolean,
+			default: !1
+		},
+		maximized: {
+			type: Boolean,
+			default: !1
+		},
+		draggable: {
+			type: Boolean,
+			default: !0
+		},
+		resizable: {
+			type: Boolean,
+			default: !0
+		},
+		bounds: {},
+		class: {}
+	},
+	emits: [
+		"focus",
+		"close",
+		"minimize",
+		"maximize",
+		"restore",
+		"move",
+		"resize"
+	],
+	setup(t, { emit: r }) {
+		let l = t, u = r, { dragging: p, start: h } = w({
+			position() {
+				return l.position;
+			},
+			size() {
+				return l.size;
+			},
+			bounds() {
+				return l.bounds;
+			},
+			onMove(e) {
+				u("move", e);
+			}
+		}), { start: _ } = T({
+			position() {
+				return l.position;
+			},
+			size() {
+				return l.size;
+			},
+			bounds() {
+				return l.bounds;
+			},
+			onResize(e, t) {
+				u("resize", e, t);
+			}
+		}), E = n(() => l.maximized ? {
+			inset: "0",
+			zIndex: l.zIndex
+		} : {
+			left: `${l.position.x}px`,
+			top: `${l.position.y}px`,
+			width: `${l.size.width}px`,
+			height: `${l.size.height}px`,
+			zIndex: l.zIndex
+		});
+		return (n, r) => (m(), a("section", {
+			style: f(E.value),
+			class: d(y(e)("absolute flex flex-col overflow-hidden", "rounded-lg border bg-white dark:border-slate-600 dark:bg-slate-900 shadow-xl", l.class)),
+			onMousedown: r[16] ||= (e) => u("focus")
+		}, [
+			o("header", {
+				class: d(["flex h-10 shrink-0 items-center justify-between border-b dark:border-slate-600 px-3", {
+					"cursor-move": t.draggable && !t.maximized && !y(p),
+					"cursor-default": !t.draggable || t.maximized,
+					"cursor-grabbing": y(p)
+				}]),
+				onMousedown: r[7] ||= (e) => t.draggable && !t.maximized && y(h)(e)
+			}, [o("div", k, [g(n.$slots, "header", {}, () => [o("span", A, v(t.title), 1)])]), o("div", {
+				class: "flex shrink-0 items-center gap-1",
+				onMousedown: r[6] ||= C(() => {}, ["stop"])
+			}, [
+				g(n.$slots, "header-actions"),
+				g(n.$slots, "header-button-minimize", {}, () => [c(O, {
+					type: "button",
+					variant: "ghost",
+					size: "sm",
+					onMousedown: r[0] ||= C(() => {}, ["stop"]),
+					onClick: r[1] ||= (e) => u("minimize")
+				}, {
+					default: x(() => [...r[17] ||= [s(" - ", -1)]]),
+					_: 1
+				})]),
+				g(n.$slots, "header-button-maximize", {}, () => [c(O, {
+					type: "button",
+					variant: "ghost",
+					size: "sm",
+					onMousedown: r[2] ||= C(() => {}, ["stop"]),
+					onClick: r[3] ||= (e) => l.maximized ? u("restore") : u("maximize")
+				}, {
+					default: x(() => [...r[18] ||= [s(" □ ", -1)]]),
+					_: 1
+				})]),
+				g(n.$slots, "header-button-close", {}, () => [c(O, {
+					type: "button",
+					variant: "ghost",
+					size: "sm",
+					onMousedown: r[4] ||= C(() => {}, ["stop"]),
+					onClick: r[5] ||= (e) => u("close")
+				}, {
+					default: x(() => [...r[19] ||= [s(" x ", -1)]]),
+					_: 1
+				})])
+			], 32)], 34),
+			S(o("main", j, [g(n.$slots, "default")], 512), [[b, !t.minimized]]),
+			t.resizable && !t.maximized ? (m(), a("div", M, [
+				o("div", {
+					class: "pointer-events-auto absolute left-2 right-2 top-0 h-1 cursor-n-resize",
+					onMousedown: r[8] ||= C((e) => y(_)(e, "n"), ["stop"])
+				}, null, 32),
+				o("div", {
+					class: "pointer-events-auto absolute bottom-0 left-2 right-2 h-1 cursor-s-resize",
+					onMousedown: r[9] ||= C((e) => y(_)(e, "s"), ["stop"])
+				}, null, 32),
+				o("div", {
+					class: "pointer-events-auto absolute bottom-2 right-0 top-2 w-1 cursor-e-resize",
+					onMousedown: r[10] ||= C((e) => y(_)(e, "e"), ["stop"])
+				}, null, 32),
+				o("div", {
+					class: "pointer-events-auto absolute bottom-2 left-0 top-2 w-1 cursor-w-resize",
+					onMousedown: r[11] ||= C((e) => y(_)(e, "w"), ["stop"])
+				}, null, 32),
+				o("div", {
+					class: "pointer-events-auto absolute right-0 top-0 h-2 w-2 cursor-ne-resize",
+					onMousedown: r[12] ||= C((e) => y(_)(e, "ne"), ["stop"])
+				}, null, 32),
+				o("div", {
+					class: "pointer-events-auto absolute left-0 top-0 h-2 w-2 cursor-nw-resize",
+					onMousedown: r[13] ||= C((e) => y(_)(e, "nw"), ["stop"])
+				}, null, 32),
+				o("div", {
+					class: "pointer-events-auto absolute bottom-0 right-0 h-2 w-2 cursor-se-resize",
+					onMousedown: r[14] ||= C((e) => y(_)(e, "se"), ["stop"])
+				}, null, 32),
+				o("div", {
+					class: "pointer-events-auto absolute bottom-0 left-0 h-2 w-2 cursor-sw-resize",
+					onMousedown: r[15] ||= C((e) => y(_)(e, "sw"), ["stop"])
+				}, null, 32)
+			])) : i("", !0)
+		], 38));
+	}
+}), P = t({
+	base: [
+		"fixed",
+		"inset-0",
+		"z-40",
+		"bg-black"
+	],
+	variants: {
+		opacity: {
+			light: "opacity-25",
+			medium: "opacity-50",
+			dark: "opacity-75"
+		},
+		blur: {
+			none: "",
+			sm: "backdrop-blur-sm",
+			md: "backdrop-blur-md",
+			lg: "backdrop-blur-lg"
+		}
+	},
+	defaultVariants: {
+		opacity: "medium",
+		blur: "none"
+	}
+}), F = /* @__PURE__ */ l({
+	__name: "Overlay",
+	props: {
+		opacity: { default: "medium" },
+		blur: { default: "none" },
+		closeOnClick: {
+			type: Boolean,
+			default: !0
+		},
+		class: {}
+	},
+	emits: ["click"],
+	setup(t, { emit: r }) {
+		let i = t, o = r, s = n(() => e(P.compose(i), i.class));
+		function c(e) {
+			i.closeOnClick && o("click", e);
+		}
+		return (e, t) => (m(), a("div", {
+			class: d(s.value),
+			"aria-hidden": "true",
+			onClick: c
+		}, null, 2));
+	}
+});
+export { E as a, O as i, P as n, T as o, N as r, w as s, F as t };

package/dist/component-stack-hueBuq7p.js

@@ -0,0 +1,105 @@
+import { Fragment as e, Teleport as t, computed as n, createBlock as r, createElementBlock as i, defineComponent as a, guardReactiveProps as o, inject as s, markRaw as c, normalizeProps as l, normalizeStyle as u, openBlock as d, ref as f, renderList as p, renderSlot as m, resolveDynamicComponent as h, unref as g } from "vue";
+import { defineStore as _, storeToRefs as v } from "pinia";
+// src/core/component-stack/store/ComponentStackStore.ts
+var y = _("component-stack", () => {
+	let e = f([]), t = n(() => e.value.length), r = n(() => t.value === 0), i = n(() => e.value[e.value.length - 1]);
+	function a(t) {
+		e.value.push(t);
+	}
+	function o() {
+		return e.value.pop();
+	}
+	function s(t) {
+		let n = e.value.findIndex((e) => e.id === t);
+		if (n === -1) return;
+		let [r] = e.value.splice(n, 1);
+		return r;
+	}
+	function c(e) {
+		let t = o();
+		return a(e), t;
+	}
+	function l() {
+		let t = [...e.value];
+		return e.value = [], t;
+	}
+	return {
+		stack: e,
+		size: t,
+		isEmpty: r,
+		top: i,
+		push: a,
+		pop: o,
+		remove: s,
+		replace: c,
+		clear: l
+	};
+}), b = class {
+	get store() {
+		return y();
+	}
+	push(e, t = {}, n = {}) {
+		let r = {
+			id: crypto.randomUUID(),
+			component: c(e),
+			props: t,
+			options: n
+		};
+		return this.store.push(r), r;
+	}
+	pop() {
+		return this.store.pop();
+	}
+	remove(e) {
+		return this.store.remove(e);
+	}
+	replace(e, t = {}, n = {}) {
+		let r = {
+			id: crypto.randomUUID(),
+			component: c(e),
+			props: t,
+			options: n
+		};
+		return this.store.replace(r), r;
+	}
+	clear() {
+		return this.store.clear();
+	}
+}, x = Symbol("relationship-ui:component-stack"), S = /* @__PURE__ */ a({
+	__name: "ComponentWrapper",
+	props: { item: {} },
+	setup(e) {
+		let t = e, a = n(() => t.item.options?.zIndex);
+		return (t, n) => (d(), i("div", {
+			class: "component-stack__wrapper",
+			style: u({ zIndex: a.value })
+		}, [
+			m(t.$slots, "before"),
+			(d(), r(h(e.item.component), l(o(e.item.props)), null, 16)),
+			m(t.$slots, "after")
+		], 4));
+	}
+}), C = /* @__PURE__ */ a({
+	__name: "ComponentStackRenderer",
+	setup(n) {
+		let a = y(), { stack: o } = v(a);
+		return (n, a) => (d(), r(t, { to: "body" }, [(d(!0), i(e, null, p(g(o), (e) => (d(), r(S, {
+			key: e.id,
+			item: e
+		}, null, 8, ["item"]))), 128))]));
+	}
+});
+// src/core/component-stack/plugin.ts
+function w() {
+	return { install(e) {
+		let t = new b();
+		e.provide(x, t), e.component("ComponentStackRenderer", C);
+	} };
+}
+// src/core/component-stack/composables/useComponentStack.ts
+function T() {
+	let e = s(x);
+	if (!e) throw Error("ComponentStackService was not installed.");
+	return e;
+}
+export { x as a, S as i, w as n, b as o, C as r, y as s, T as t };

package/dist/components/base/avatar/Avatar.vue.d.ts

@@ -0,0 +1,6 @@
+import { AvatarProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<AvatarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AvatarProps> & Readonly<{}>, {
+    size: import('./types').AvatarSize;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/base/avatar/avatar.variants.d.ts

@@ -0,0 +1,8 @@
+export declare const avatarVariants: import('../../../utils').VariantComposer<{
+    size: {
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+}>;

package/dist/components/base/avatar/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './avatar.variants';
+export { default as Avatar } from './Avatar.vue';

package/dist/components/base/avatar/types.d.ts

@@ -0,0 +1,8 @@
+export type AvatarSize = 'sm' | 'md' | 'lg' | 'xl';
+export type AvatarProps = {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: AvatarSize;
+    class?: string;
+};

package/dist/components/base/badge/Badge.vue.d.ts

@@ -0,0 +1,19 @@
+import { BadgeProps } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<BadgeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BadgeProps> & Readonly<{}>, {
+    size: import('./types').BadgeSize;
+    variant: import('./types').BadgeVariant;
+}, {}, {}, {}, 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/base/badge/badge.variants.d.ts

@@ -0,0 +1,16 @@
+export declare const badgeVariants: import('../../../utils').VariantComposer<{
+    variant: {
+        default: string[];
+        secondary: string[];
+        success: string[];
+        warning: string[];
+        danger: string[];
+        info: string[];
+        outline: string[];
+    };
+    size: {
+        sm: string[];
+        md: string[];
+        lg: string[];
+    };
+}>;

package/dist/components/base/badge/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './badge.variants';
+export { default as Badge } from './Badge.vue';

package/dist/components/base/badge/types.d.ts

@@ -0,0 +1,7 @@
+export type BadgeVariant = 'default' | 'secondary' | 'success' | 'warning' | 'danger' | 'info' | 'outline';
+export type BadgeSize = 'sm' | 'md' | 'lg';
+export type BadgeProps = {
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    class?: string;
+};

package/dist/components/base/button/Button.vue.d.ts

@@ -0,0 +1,21 @@
+import { ButtonProps } from './types';
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        default?: (props: {}) => any;
+    };
+};
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import('vue').DefineComponent<ButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
+    disabled: boolean;
+    as: string;
+    loading: boolean;
+    type: "button" | "reset" | "submit";
+}, {}, {}, {}, 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/base/button/button.variants.d.ts

@@ -0,0 +1,19 @@
+export declare const buttonVariants: import('../../../utils').VariantComposer<{
+    variant: {
+        filled: string[];
+        outlined: string[];
+        ghost: string[];
+    };
+    size: {
+        sm: string[];
+        md: string[];
+        lg: string[];
+    };
+    rounded: {
+        none: string;
+        sm: string;
+        md: string;
+        lg: string;
+        full: string;
+    };
+}>;

package/dist/components/base/button/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './button.variants';
+export { default as Button } from './Button.vue';