vlite3 0.1.0 → 0.1.2

package/components/Alert.vue.js

@@ -0,0 +1,84 @@
+import { defineComponent as C, ref as V, computed as a, useSlots as $, openBlock as n, createElementBlock as i, normalizeClass as r, renderSlot as d, createBlock as B, createCommentVNode as o, createElementVNode as g, toDisplayString as v, createTextVNode as N, createVNode as S } from "vue";
+import m from "./Icon.vue.js";
+const j = ["role"], E = {
+  key: 1,
+  class: "text-sm opacity-90 [&_p]:leading-relaxed"
+}, A = /* @__PURE__ */ C({
+  __name: "Alert",
+  props: {
+    title: {},
+    description: {},
+    icon: {},
+    variant: { default: "primary" },
+    closable: { type: Boolean, default: !1 },
+    role: {},
+    class: { default: "" }
+  },
+  emits: ["close"],
+  setup(e, { emit: f }) {
+    const t = e, p = f, c = V(!0), y = () => {
+      c.value = !1, p("close");
+    }, b = a(() => ({
+      primary: "bg-primary-light text-primary border-primary/15",
+      success: "bg-success-light text-success-dark border-success/25",
+      warning: "bg-warning-light text-warning-dark border-warning/20",
+      danger: "bg-danger-light text-danger-dark border-danger/15"
+    })[t.variant]), k = a(() => ({
+      primary: "text-primary!",
+      success: "text-success-dark!",
+      warning: "text-warning-dark!",
+      danger: "text-danger-dark!"
+    })[t.variant]), l = a(() => !t.description && !$().default), x = a(() => [
+      "relative w-full rounded-lg border px-4 [&>svg]:absolute [&>svg]:left-4 [&>svg]:text-foreground",
+      l.value ? "py-3" : "pt-4 pb-2",
+      // Icon Position: Center vertically if title only, otherwise top-4
+      l.value ? "[&>svg]:top-1/2 [&>svg]:-translate-y-1/2" : "[&>svg]:top-4 top-4 [&>svg+div]:translate-y-[-3px]",
+      b.value,
+      t.class
+    ].join(" ")), h = a(() => [
+      "font-medium leading-none tracking-tight text-inherit!",
+      l.value ? "" : "mb-1"
+    ].join(" ")), w = a(() => t.role ? t.role : ["danger", "warning"].includes(t.variant) ? "alert" : "status");
+    return (s, u) => c.value ? (n(), i("div", {
+      key: 0,
+      class: r(x.value),
+      role: w.value
+    }, [
+      d(s.$slots, "icon", {}, () => [
+        e.icon ? (n(), B(m, {
+          key: 0,
+          icon: e.icon,
+          class: r(["h-4 w-4", k.value])
+        }, null, 8, ["icon", "class"])) : o("", !0)
+      ]),
+      g("div", {
+        class: r({ "pl-7": e.icon || s.$slots.icon, "pr-6": e.closable })
+      }, [
+        e.title ? (n(), i("h5", {
+          key: 0,
+          class: r(h.value)
+        }, v(e.title), 3)) : o("", !0),
+        e.description || s.$slots.default ? (n(), i("div", E, [
+          d(s.$slots, "default", {}, () => [
+            N(v(e.description), 1)
+          ])
+        ])) : o("", !0)
+      ], 2),
+      e.closable ? (n(), i("button", {
+        key: 0,
+        type: "button",
+        onClick: y,
+        class: r(["absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", [l.value ? "top-1/2 -translate-y-1/2" : "top-4"]])
+      }, [
+        S(m, {
+          icon: "lucide:x",
+          class: "h-4 w-4"
+        }),
+        u[0] || (u[0] = g("span", { class: "sr-only" }, "Close", -1))
+      ], 2)) : o("", !0)
+    ], 10, j)) : o("", !0);
+  }
+});
+export {
+  A as default
+};

package/components/Alert.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Alert.vue.js";
+export {
+  f as default
+};

package/components/Avatar.vue.d.ts

@@ -0,0 +1,32 @@
+import { AvatarSize, AvatarRounded } from '../types';
+interface Props {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    size?: AvatarSize;
+    rounded?: AvatarRounded;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        fallback?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    class: string;
+    src: string;
+    alt: string;
+    size: AvatarSize;
+    rounded: AvatarRounded;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/Avatar.vue.js

@@ -0,0 +1,78 @@
+import { defineComponent as k, ref as c, watch as w, computed as a, openBlock as t, createElementBlock as r, normalizeClass as d, renderSlot as b, toDisplayString as g, createBlock as C } from "vue";
+import _ from "./Icon.vue.js";
+const y = ["src", "alt"], z = { key: 0 }, A = /* @__PURE__ */ k({
+  __name: "Avatar",
+  props: {
+    src: { default: "" },
+    alt: { default: "Avatar" },
+    fallback: {},
+    size: { default: "md" },
+    rounded: { default: "full" },
+    class: { default: "" }
+  },
+  setup(o) {
+    const e = o, s = c(!1), n = c(!1);
+    w(
+      () => e.src,
+      () => {
+        s.value = !1, n.value = !1;
+      }
+    );
+    const f = () => {
+      s.value = !0, n.value = !1;
+    }, i = () => {
+      n.value = !0, s.value = !1;
+    }, m = a(() => e.src && !s.value), u = a(() => {
+      if (e.fallback) return e.fallback;
+      if (!e.alt) return "";
+      const l = e.alt.trim().split(/\s+/);
+      return l.length === 1 ? l[0].slice(0, 2).toUpperCase() : (l[0][0] + l[l.length - 1][0]).toUpperCase();
+    }), x = {
+      xs: "h-6 w-6 text-[10px]",
+      sm: "h-8 w-8 text-xs",
+      md: "h-10 w-10 text-sm",
+      lg: "h-14 w-14 text-base",
+      xl: "h-20 w-20 text-lg",
+      "2xl": "h-22 w-22 text-xl"
+    }, h = {
+      none: "rounded-none",
+      sm: "rounded-sm",
+      md: "rounded-md",
+      lg: "rounded-lg",
+      xl: "rounded-xl",
+      "2xl": "rounded-2xl",
+      full: "rounded-full"
+    }, v = a(() => [
+      "relative flex shrink-0 overflow-hidden bg-muted border border-border/50",
+      x[e.size],
+      h[e.rounded],
+      e.class
+    ].join(" ")), p = a(() => "flex h-full w-full items-center justify-center bg-muted text-muted-foreground font-medium");
+    return (l, j) => (t(), r("div", {
+      class: d(v.value)
+    }, [
+      m.value ? (t(), r("img", {
+        key: 0,
+        src: o.src,
+        alt: o.alt,
+        class: "aspect-square h-full w-full object-cover",
+        onError: f,
+        onLoad: i
+      }, null, 40, y)) : (t(), r("div", {
+        key: 1,
+        class: d(p.value)
+      }, [
+        b(l.$slots, "fallback", {}, () => [
+          u.value ? (t(), r("span", z, g(u.value), 1)) : (t(), C(_, {
+            key: 1,
+            icon: "lucide:user",
+            class: "h-1/2 w-1/2"
+          }))
+        ])
+      ], 2))
+    ], 2));
+  }
+});
+export {
+  A as default
+};

package/components/Avatar.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Avatar.vue.js";
+export {
+  f as default
+};

package/components/AvatarUploader/AvatarUploader.vue.d.ts

@@ -0,0 +1,32 @@
+import { FilePickerValue } from '../FilePicker/FilePicker.vue';
+import { AvatarSize, AvatarRounded } from '../../types';
+export interface Props {
+    modelValue?: any;
+    size?: AvatarSize;
+    rounded?: AvatarRounded;
+    editable?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    fallback?: string;
+    alt?: string;
+    maxSize?: number;
+    className?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    change: (value: FilePickerValue) => any;
+    error: (error: string) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+    onChange?: (value: FilePickerValue) => any;
+    onError?: (error: string) => any;
+}>, {
+    disabled: boolean;
+    alt: string;
+    size: AvatarSize;
+    modelValue: any;
+    loading: boolean;
+    rounded: AvatarRounded;
+    editable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/components/AvatarUploader/AvatarUploader.vue.js

@@ -0,0 +1,99 @@
+import { defineComponent as x, ref as w, computed as z, openBlock as n, createElementBlock as o, createElementVNode as b, normalizeClass as l, createVNode as d, withCtx as C, createCommentVNode as f, withModifiers as A } from "vue";
+import u from "../Icon.vue.js";
+import B from "../FilePicker/FilePicker.vue.js";
+import N from "../Avatar.vue.js";
+const E = { class: "inline-block" }, $ = ["onClick"], I = /* @__PURE__ */ x({
+  name: "AvatarUploader",
+  __name: "AvatarUploader",
+  props: {
+    modelValue: { default: null },
+    size: { default: "xl" },
+    rounded: { default: "full" },
+    editable: { type: Boolean, default: !0 },
+    loading: { type: Boolean, default: !1 },
+    disabled: { type: Boolean, default: !1 },
+    fallback: {},
+    alt: { default: "Avatar" },
+    maxSize: {},
+    className: {}
+  },
+  emits: ["update:modelValue", "change", "error"],
+  setup(e, { emit: g }) {
+    const v = e, t = g, i = w(null), s = z(() => i.value || v.modelValue), h = (a) => {
+      if (!a || Array.isArray(a)) {
+        Array.isArray(a) && a.length === 0 && c();
+        return;
+      }
+      a.base64 && (i.value = a.base64, t("update:modelValue", a.base64)), t("change", a);
+    }, y = (a) => {
+      t("error", a);
+    }, c = () => {
+      i.value = null, t("update:modelValue", null), t("change", null);
+    };
+    return (a, m) => (n(), o("div", E, [
+      b("div", {
+        class: l(["relative inline-block group", e.rounded === "full" ? "rounded-full" : "rounded-md"])
+      }, [
+        d(N, {
+          src: s.value || void 0,
+          fallback: e.fallback,
+          alt: e.alt,
+          size: e.size,
+          rounded: e.rounded,
+          class: l(e.className)
+        }, null, 8, ["src", "fallback", "alt", "size", "rounded", "class"]),
+        d(B, {
+          disabled: !e.editable || e.disabled || e.loading,
+          "return-format": "base64",
+          "file-types": ["image/jpeg", "image/png", "image/webp", "image/gif"],
+          "max-size": e.maxSize,
+          class: "absolute inset-0",
+          onChange: m[0] || (m[0] = (r) => h(r)),
+          onError: y
+        }, {
+          trigger: C(({ trigger: r, isLoading: k }) => [
+            b("button", {
+              type: "button",
+              class: l(["absolute inset-0 cursor-pointer", { "cursor-default": !e.editable || e.disabled }]),
+              onClick: (j) => e.editable && !e.disabled ? r() : null
+            }, [
+              e.loading || k ? (n(), o("div", {
+                key: 0,
+                class: l(["absolute inset-0 flex items-center justify-center bg-black/40 text-white", e.rounded === "full" ? "rounded-full" : "rounded-md"])
+              }, [
+                d(u, {
+                  icon: "lucide:loader-2",
+                  class: "animate-spin w-1/3 h-1/3"
+                })
+              ], 2)) : e.editable && !e.disabled ? (n(), o("div", {
+                key: 1,
+                class: l(["absolute inset-0 flex items-center justify-center bg-black/40 text-white opacity-0 group-hover:opacity-100 transition-opacity", e.rounded === "full" ? "rounded-full" : "rounded-md"])
+              }, [
+                d(u, {
+                  icon: "lucide:camera",
+                  class: "w-1/3 h-1/3"
+                })
+              ], 2)) : f("", !0)
+            ], 10, $)
+          ]),
+          _: 1
+        }, 8, ["disabled", "max-size"]),
+        s.value && e.editable && !e.disabled && !e.loading ? (n(), o("button", {
+          key: 0,
+          type: "button",
+          class: "absolute -top-1 -right-1 z-10 p-1 bg-background border border-border rounded-full text-muted-foreground shadow-sm hover:text-destructive hover:border-destructive transition-all opacity-0 group-hover:opacity-100 scale-75 group-hover:scale-100",
+          onClick: A(c, ["stop"]),
+          title: "Remove image"
+        }, [
+          d(u, {
+            icon: "lucide:x",
+            class: "w-3 h-3"
+          })
+        ])) : f("", !0)
+      ], 2)
+    ]));
+  }
+});
+export {
+  I as default
+};

package/components/AvatarUploader/AvatarUploader.vue2.js

@@ -0,0 +1,4 @@
+import f from "./AvatarUploader.vue.js";
+export {
+  f as default
+};

package/{src/components/AvatarUploader/index.ts → components/AvatarUploader/index.d.ts}

@@ -1,2 +1,2 @@
-export { default as AvatarUploader } from './AvatarUploader.vue'
-export type { Props as AvatarUploaderProps } from './AvatarUploader.vue'
+export { default as AvatarUploader } from './AvatarUploader.vue';
+export type { Props as AvatarUploaderProps } from './AvatarUploader.vue';

package/components/Badge.vue.d.ts

@@ -0,0 +1,25 @@
+export type BadgeVariant = 'default' | 'secondary' | 'danger' | 'outline' | 'warning' | 'info' | 'success';
+interface Props {
+    variant?: BadgeVariant;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    class: string;
+    variant: BadgeVariant;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/Badge.vue.js

@@ -0,0 +1,27 @@
+import { defineComponent as o, computed as a, openBlock as c, createElementBlock as i, normalizeClass as d, renderSlot as u } from "vue";
+const g = /* @__PURE__ */ o({
+  __name: "Badge",
+  props: {
+    variant: { default: "default" },
+    class: { default: "" }
+  },
+  setup(n) {
+    const e = n, t = a(() => ["inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", {
+      default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+      secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+      danger: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+      warning: "border-transparent bg-warning text-warning-fg hover:bg-warning/80",
+      info: "border-transparent bg-info text-info-fg hover:bg-info/80",
+      success: "border-transparent bg-success text-success-fg hover:bg-success/80",
+      outline: "text-foreground border-border"
+    }[e.variant], e.class].join(" "));
+    return (r, s) => (c(), i("div", {
+      class: d(t.value)
+    }, [
+      u(r.$slots, "default")
+    ], 2));
+  }
+});
+export {
+  g as default
+};

package/components/Badge.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Badge.vue.js";
+export {
+  f as default
+};

package/components/Button.vue.d.ts

@@ -0,0 +1,26 @@
+import { ButtonVariant, ButtonSize, ButtonRounded, ButtonProps } from '../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
+    disabled: boolean;
+    type: "button" | "submit" | "reset";
+    class: any;
+    size: ButtonSize;
+    variant: ButtonVariant;
+    loading: boolean;
+    rounded: ButtonRounded;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/Button.vue.js

@@ -0,0 +1,107 @@
+import { defineComponent as v, useSlots as x, computed as s, withDirectives as y, openBlock as r, createElementBlock as w, normalizeClass as i, createBlock as a, createCommentVNode as u, renderSlot as p, createTextVNode as k, toDisplayString as z, unref as B } from "vue";
+import l from "./Icon.vue.js";
+import { vRipple as C } from "../directives/vRipple.js";
+const R = ["type", "disabled"], D = /* @__PURE__ */ v({
+  __name: "Button",
+  props: {
+    variant: { default: "primary" },
+    size: { default: "md" },
+    class: { default: "" },
+    disabled: { type: Boolean, default: !1 },
+    loading: { type: Boolean, default: !1 },
+    icon: {},
+    iconRight: {},
+    type: { default: "button" },
+    text: {},
+    rounded: { default: "md" }
+  },
+  setup(e) {
+    const t = e, g = x(), c = s(() => t.icon && !t.text && !g.default), h = s(() => {
+      const n = "inline-flex items-center justify-center whitespace-nowrap text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 active:scale-95 cursor-pointer gap-2", d = {
+        primary: "bg-primary text-primary-foreground hover:bg-primary/90",
+        "primary-light": "bg-primary-light text-primary-fg-light hover:bg-primary/20",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        danger: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+        "danger-light": "bg-destructive/10 text-destructive hover:bg-destructive/20",
+        warning: "bg-warning text-warning-fg hover:bg-warning/80",
+        "warning-light": "bg-warning-light text-warning-fg-light hover:bg-warning/20",
+        info: "bg-info text-info-fg hover:bg-info/80",
+        "info-light": "bg-info-light text-info-fg-light hover:bg-info/20",
+        success: "bg-success text-success-fg hover:bg-success/80",
+        "success-light": "bg-success-light text-success-fg-light hover:bg-success/20",
+        outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground text-foreground",
+        "outline-primary": "border border-primary text-primary hover:bg-primary/10",
+        "outline-danger": "border border-destructive text-destructive hover:bg-destructive/10",
+        "outline-warning": "border border-warning text-warning hover:bg-warning/10",
+        "outline-info": "border border-info text-info hover:bg-info/10",
+        "outline-success": "border border-success text-success hover:bg-success/10",
+        ghost: "hover:bg-accent hover:text-accent-foreground text-foreground",
+        link: "text-primary underline-offset-4 hover:underline"
+      }, f = {
+        xs: "h-6.5 px-2",
+        sm: "h-8 px-3",
+        md: "h-9 px-4 py-2",
+        lg: "h-10 px-8",
+        xl: "h-12 px-10"
+      }, b = {
+        xs: "h-6.5 w-6.5 min-h-6.5 min-w-6.5",
+        sm: "h-8 w-8 min-h-9 min-w-9",
+        md: "h-9 w-9 min-h-9 min-w-9",
+        lg: "h-10 w-10 min-h-11 min-w-11",
+        xl: "h-12 w-12 min-h-12 min-w-12"
+      }, m = {
+        none: "rounded-none",
+        sm: "rounded-sm",
+        md: "rounded",
+        lg: "rounded-lg",
+        xl: "rounded-xl",
+        "2xl": "rounded-2xl",
+        full: "rounded-full"
+      };
+      return [
+        n,
+        d[t.variant],
+        m[t.rounded],
+        c.value ? b[t.size] : f[t.size],
+        t.class
+      ].join(" ");
+    }), o = s(() => ({
+      xs: "w-3 h-3",
+      sm: "w-4 h-4",
+      md: "w-4 h-4",
+      lg: "w-4 h-4",
+      xl: "w-4 h-4"
+    })[t.size]);
+    return (n, d) => y((r(), w("button", {
+      type: e.type,
+      class: i(h.value),
+      disabled: e.disabled || e.loading
+    }, [
+      e.loading ? (r(), a(l, {
+        key: 0,
+        icon: "lucide:loader-2",
+        class: i(["animate-spin", { [o.value]: !0 }])
+      }, null, 8, ["class"])) : e.icon ? (r(), a(l, {
+        key: 1,
+        icon: e.icon,
+        class: i({
+          "mx-auto": c.value,
+          [o.value]: !0
+        })
+      }, null, 8, ["icon", "class"])) : u("", !0),
+      p(n.$slots, "default", {}, () => [
+        k(z(e.text), 1)
+      ]),
+      e.iconRight && !e.loading ? (r(), a(l, {
+        key: 2,
+        icon: e.iconRight,
+        class: i([o.value, "h-4 w-4"])
+      }, null, 8, ["icon", "class"])) : u("", !0)
+    ], 10, R)), [
+      [B(C)]
+    ]);
+  }
+});
+export {
+  D as default
+};

package/components/Button.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Button.vue.js";
+export {
+  f as default
+};

package/components/ButtonGroup.vue.d.ts

@@ -0,0 +1,29 @@
+import { ButtonGroupDirection, ButtonVariant, ButtonSize } from '../types';
+interface Props {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    direction?: ButtonGroupDirection;
+    attached?: boolean;
+    class?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    class: string;
+    attached: boolean;
+    direction: ButtonGroupDirection;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/ButtonGroup.vue.js

@@ -0,0 +1,7 @@
+import o from "./ButtonGroup.vue2.js";
+/* empty css                 */
+import t from "../_virtual/_plugin-vue_export-helper.js";
+const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-8c9add3e"]]);
+export {
+  m as default
+};

package/components/ButtonGroup.vue2.js

@@ -0,0 +1,30 @@
+import { defineComponent as l, computed as r, openBlock as c, createElementBlock as n, normalizeClass as i, renderSlot as s } from "vue";
+const p = /* @__PURE__ */ l({
+  __name: "ButtonGroup",
+  props: {
+    variant: {},
+    size: {},
+    direction: { default: "horizontal" },
+    attached: { type: Boolean, default: !0 },
+    class: { default: "" }
+  },
+  setup(e) {
+    const t = e, a = r(() => t.direction === "vertical");
+    return (o, u) => (c(), n("div", {
+      role: "group",
+      class: i([
+        "inline-flex",
+        a.value ? "flex-col" : "flex-row",
+        t.class,
+        e.attached ? "attached-group" : "gap-2",
+        // Vertical Attached
+        e.attached && a.value ? "vertical-group" : ""
+      ])
+    }, [
+      s(o.$slots, "default", {}, void 0, !0)
+    ], 2));
+  }
+});
+export {
+  p as default
+};