@chelone/vue 0.0.0-stage → 0.1.0

package/dist/components/ui/avatar.js

@@ -0,0 +1,91 @@
+import { h, defineComponent, ref } from "vue";
+import { cn } from "../../lib/utils.js";
+const AVATAR_SIZE_CLASS = {
+  default: "size-8",
+  sm: "size-6",
+  lg: "size-10"
+};
+const Avatar = (props, { slots }) => h(
+  "span",
+  {
+    "data-slot": "avatar",
+    ...props.size ? { "data-size": props.size } : {},
+    class: cn(
+      // `cn` does not merge conflicts, so a size replaces the default class.
+      props.size && "group/avatar",
+      "relative flex",
+      AVATAR_SIZE_CLASS[props.size ?? "default"],
+      "shrink-0 overflow-hidden rounded-full",
+      props.class
+    )
+  },
+  slots.default?.()
+);
+Avatar.props = ["class", "size"];
+Avatar.displayName = "Avatar";
+const AvatarImage = defineComponent({
+  name: "AvatarImage",
+  props: {
+    src: { type: String, default: void 0 },
+    alt: { type: String, default: void 0 },
+    class: { type: String, default: void 0 }
+  },
+  setup(props) {
+    const failed = ref(false);
+    return () => !props.src || failed.value ? null : h("img", {
+      src: props.src,
+      alt: props.alt,
+      "data-slot": "avatar-image",
+      class: cn("aspect-square size-full object-cover", props.class),
+      onError: () => {
+        failed.value = true;
+      }
+    });
+  }
+});
+const AvatarFallback = (props, { slots }) => h(
+  "span",
+  {
+    "data-slot": "avatar-fallback",
+    class: cn(
+      "flex size-full items-center justify-center rounded-full bg-muted text-sm group-data-[size=sm]/avatar:text-xs",
+      props.class
+    )
+  },
+  slots.default?.()
+);
+AvatarFallback.props = ["class"];
+AvatarFallback.displayName = "AvatarFallback";
+const AvatarGroup = (props, { slots }) => h(
+  "div",
+  {
+    "data-slot": "avatar-group",
+    class: cn(
+      "group/avatar-group flex -space-x-2 *:data-[slot=avatar]:ring-2 *:data-[slot=avatar]:ring-background",
+      props.class
+    )
+  },
+  slots.default?.()
+);
+AvatarGroup.props = ["class"];
+AvatarGroup.displayName = "AvatarGroup";
+const AvatarGroupCount = (props, { slots }) => h(
+  "div",
+  {
+    "data-slot": "avatar-group-count",
+    class: cn(
+      "relative flex size-8 shrink-0 items-center justify-center rounded-full bg-muted text-sm text-muted-foreground ring-2 ring-background group-has-data-[size=lg]/avatar-group:size-10 group-has-data-[size=sm]/avatar-group:size-6 [&>svg]:size-4 group-has-data-[size=lg]/avatar-group:[&>svg]:size-5 group-has-data-[size=sm]/avatar-group:[&>svg]:size-3",
+      props.class
+    )
+  },
+  slots.default?.()
+);
+AvatarGroupCount.props = ["class"];
+AvatarGroupCount.displayName = "AvatarGroupCount";
+export {
+  Avatar,
+  AvatarFallback,
+  AvatarGroup,
+  AvatarGroupCount,
+  AvatarImage
+};

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The shadcn `Badge`, the Vue analog of `@chelone/react`'s `ui/badge.tsx`. A
+ * pure structural `defineComponent` render component (mirrors the `card.ts` /
+ * `table.ts` style in this `ui/` slice). Renders a `<span>` with the variant's
+ * class map; `chip-field` / `badge-field` compose it. The React twin builds its
+ * classes with `cva`; here the (small, fixed) variant set is a literal map — no
+ * runtime cva dep — with the same visual contract.
+ */
+/** The badge visual variants (parity with the React `badgeVariants` set). */
+export type BadgeVariant = "default" | "outline" | "secondary" | "destructive";
+export declare const Badge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    variant: {
+        type: () => BadgeVariant;
+        default: string;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    variant: {
+        type: () => BadgeVariant;
+        default: string;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    variant: BadgeVariant;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/components/ui/badge.js

@@ -0,0 +1,30 @@
+import { defineComponent, h } from "vue";
+import { cn } from "../../lib/utils.js";
+const BADGE_BASE = "inline-flex w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-full border border-transparent px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-[color,box-shadow] [&>svg]:pointer-events-none [&>svg]:size-3";
+const BADGE_VARIANTS = {
+  default: "bg-primary text-primary-foreground",
+  secondary: "bg-secondary text-secondary-foreground",
+  destructive: "bg-destructive text-white",
+  outline: "border-border text-foreground"
+};
+const Badge = defineComponent({
+  name: "Badge",
+  props: {
+    variant: { type: String, default: "default" },
+    class: { type: String, default: "" }
+  },
+  setup(props, { slots }) {
+    return () => h(
+      "span",
+      {
+        "data-slot": "badge",
+        "data-variant": props.variant,
+        class: cn(BADGE_BASE, BADGE_VARIANTS[props.variant], props.class)
+      },
+      slots.default?.()
+    );
+  }
+});
+export {
+  Badge
+};

package/dist/components/ui/button-variants.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `buttonVariants({ variant, size, class })` — the shadcn button class recipe as
+ * a pure function, the Vue analog of `@chelone/react`'s `ui/button.tsx`
+ * `buttonVariants` (cva). Extracted from `button.vue` so BOTH the `<Button>`
+ * primitive AND anchor-rendered nav buttons (`<CreateButton>`/`<EditButton>`/…,
+ * which render a `RouterLink` — not a `<button>` — styled as a button) share the
+ * one class table. Kept in a `.ts` sibling so `button.vue` stays a single
+ * component file.
+ */
+/** The button visual variants. Mirrors shadcn's variant tokens. */
+export type ButtonVariant = "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+/** The button size tokens. Mirrors shadcn's size tokens. */
+export type ButtonSize = "default" | "sm" | "lg" | "icon";
+/** Options accepted by {@link buttonVariants}. */
+export interface ButtonVariantsOptions {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    class?: string;
+}
+/** Compute the shadcn button class string for a variant/size (+ extra class). */
+export declare function buttonVariants(options?: ButtonVariantsOptions): string;

package/dist/components/ui/button-variants.js

@@ -0,0 +1,23 @@
+import { cn } from "../../lib/utils.js";
+const base = "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 disabled:pointer-events-none disabled:opacity-50";
+const variantClasses = {
+  default: "bg-primary text-primary-foreground hover:bg-primary/90",
+  destructive: "bg-destructive text-destructive-foreground hover:bg-destructive/90",
+  outline: "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
+  secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+  ghost: "hover:bg-accent hover:text-accent-foreground",
+  link: "text-primary underline-offset-4 hover:underline"
+};
+const sizeClasses = {
+  default: "h-9 px-4 py-2",
+  sm: "h-8 rounded-md px-3 text-xs",
+  lg: "h-10 rounded-md px-8",
+  icon: "h-9 w-9"
+};
+function buttonVariants(options = {}) {
+  const { variant = "default", size = "default", class: extra } = options;
+  return cn(base, variantClasses[variant], sizeClasses[size], extra);
+}
+export {
+  buttonVariants
+};

package/dist/components/ui/button.vue.d.ts

@@ -0,0 +1,25 @@
+import { type ButtonSize, type ButtonVariant } from "./button-variants.js";
+type __VLS_Props = {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    type?: "button" | "submit" | "reset";
+    disabled?: boolean;
+    class?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: ButtonSize;
+    type: "button" | "submit" | "reset";
+    variant: ButtonVariant;
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/button.vue.js

@@ -0,0 +1,36 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, renderSlot } from "vue";
+import { buttonVariants } from "./button-variants.js";
+const _hoisted_1 = ["type", "disabled"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "button",
+  props: {
+    variant: { default: "default" },
+    size: { default: "default" },
+    type: { default: "button" },
+    disabled: { type: Boolean, default: false },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const classes = computed(
+      () => buttonVariants({
+        variant: props.variant,
+        size: props.size,
+        class: props.class
+      })
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        type: __props.type,
+        disabled: __props.disabled,
+        class: normalizeClass(classes.value),
+        "data-slot": "button"
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 10, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/ui/button2.vue.js

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

package/dist/components/ui/card.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The shadcn `Card` family, the Vue analog of `@chelone/react`'s `ui/card.tsx`.
+ * Pure structural wrappers as `defineComponent` render components. The V1 slice
+ * uses `Card` as the optional container shell for Edit/Create form bodies.
+ */
+export declare const Card: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const CardHeader: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const CardTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const CardContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const CardFooter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/components/ui/card.js

@@ -0,0 +1,33 @@
+import { defineComponent, h } from "vue";
+import { cn } from "../../lib/utils.js";
+function part(name, baseClass, tag = "div") {
+  return defineComponent({
+    name,
+    props: { class: { type: String, default: "" } },
+    setup(props, { slots }) {
+      return () => h(
+        tag,
+        {
+          "data-slot": name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase(),
+          class: cn(baseClass, props.class)
+        },
+        slots.default?.()
+      );
+    }
+  });
+}
+const Card = part(
+  "Card",
+  "rounded-xl border bg-card text-card-foreground shadow"
+);
+const CardHeader = part("CardHeader", "flex flex-col gap-1.5 p-6");
+const CardTitle = part("CardTitle", "font-semibold leading-none", "h3");
+const CardContent = part("CardContent", "p-6 pt-0");
+const CardFooter = part("CardFooter", "flex items-center p-6 pt-0");
+export {
+  Card,
+  CardContent,
+  CardFooter,
+  CardHeader,
+  CardTitle
+};

package/dist/components/ui/checkbox.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    modelValue?: boolean;
+    id?: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+    class?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/ui/checkbox.vue.js

@@ -0,0 +1,42 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass } from "vue";
+import { cn } from "../../lib/utils.js";
+const _hoisted_1 = ["id", "checked", "disabled", "aria-label"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "checkbox",
+  props: {
+    modelValue: { type: Boolean },
+    id: {},
+    disabled: { type: Boolean },
+    ariaLabel: {},
+    class: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const classes = computed(
+      () => cn(
+        "h-4 w-4 shrink-0 rounded-sm border border-primary shadow focus-visible:outline-none focus-visible:ring-1 disabled:cursor-not-allowed disabled:opacity-50",
+        props.class
+      )
+    );
+    function onChange(event) {
+      emit("update:modelValue", event.target.checked);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("input", {
+        id: __props.id,
+        type: "checkbox",
+        checked: __props.modelValue,
+        disabled: __props.disabled,
+        "aria-label": __props.ariaLabel,
+        class: normalizeClass(classes.value),
+        "data-slot": "checkbox",
+        onChange
+      }, null, 42, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/ui/checkbox2.vue.js

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

package/dist/components/ui/command/command-dialog.vue.d.ts

@@ -0,0 +1,28 @@
+/** Props for {@link CommandDialog}. */
+export interface CommandDialogProps {
+    /** Whether the dialog is open. Default `false`. */
+    open?: boolean;
+    /** Screen-reader-only title; the panel is labelled by it. */
+    title?: string;
+    /** Screen-reader-only description. */
+    description?: string;
+    /** Extra CSS class appended to the panel. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CommandDialogProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<CommandDialogProps> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+}>, {
+    description: string;
+    title: string;
+    open: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/command/command-dialog.vue.js

@@ -0,0 +1,94 @@
+import { defineComponent, useId, ref, watch, nextTick, onBeforeUnmount, openBlock, createElementBlock, createElementVNode, normalizeClass, unref, toDisplayString, createVNode, withCtx, renderSlot, createCommentVNode } from "vue";
+import { cn } from "../../../lib/utils.js";
+import _sfc_main$1 from "./command.vue.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "fixed inset-0 z-50",
+  "data-slot": "command-dialog"
+};
+const _hoisted_2 = ["aria-labelledby", "aria-describedby"];
+const _hoisted_3 = ["id"];
+const _hoisted_4 = ["id"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "command-dialog",
+  props: {
+    open: { type: Boolean, default: false },
+    title: { default: "Command Palette" },
+    description: { default: "Search for a command to run..." },
+    class: {}
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const titleId = useId();
+    const descriptionId = useId();
+    const panel = ref(null);
+    function close() {
+      emit("update:open", false);
+    }
+    function onKeydown(event) {
+      if (event.key === "Escape") close();
+    }
+    watch(
+      () => props.open,
+      async (open) => {
+        if (typeof document === "undefined") return;
+        if (open) {
+          document.addEventListener("keydown", onKeydown);
+          await nextTick();
+          panel.value?.querySelector("input")?.focus();
+        } else {
+          document.removeEventListener("keydown", onKeydown);
+        }
+      },
+      { immediate: true }
+    );
+    onBeforeUnmount(() => {
+      if (typeof document !== "undefined")
+        document.removeEventListener("keydown", onKeydown);
+    });
+    return (_ctx, _cache) => {
+      return __props.open ? (openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          class: "absolute inset-0 bg-black/50",
+          "data-slot": "command-dialog-overlay",
+          onClick: close
+        }),
+        createElementVNode("div", {
+          ref_key: "panel",
+          ref: panel,
+          role: "dialog",
+          "aria-modal": "true",
+          "aria-labelledby": unref(titleId),
+          "aria-describedby": unref(descriptionId),
+          class: normalizeClass(
+            unref(cn)(
+              "fixed top-1/3 left-1/2 w-full max-w-lg -translate-x-1/2 overflow-hidden rounded-lg border bg-background p-0 shadow-lg",
+              props.class
+            )
+          ),
+          "data-slot": "command-dialog-content"
+        }, [
+          createElementVNode("h2", {
+            id: unref(titleId),
+            class: "sr-only"
+          }, toDisplayString(__props.title), 9, _hoisted_3),
+          createElementVNode("p", {
+            id: unref(descriptionId),
+            class: "sr-only"
+          }, toDisplayString(__props.description), 9, _hoisted_4),
+          createVNode(_sfc_main$1, null, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          })
+        ], 10, _hoisted_2)
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/ui/command/command-dialog2.vue.js

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

package/dist/components/ui/command/command-group.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    heading?: string;
+    class?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/command/command-group.vue.js

@@ -0,0 +1,40 @@
+import { defineComponent, useId, provide, withDirectives, openBlock, createElementBlock, normalizeClass, unref, toDisplayString, createCommentVNode, renderSlot, vShow } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { useCommand, CommandGroupKey } from "./context.js";
+const _hoisted_1 = ["aria-labelledby"];
+const _hoisted_2 = ["id"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "command-group",
+  props: {
+    heading: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const ctx = useCommand();
+    const groupId = useId();
+    const headingId = useId();
+    provide(CommandGroupKey, groupId);
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createElementBlock("div", {
+        role: "group",
+        "aria-labelledby": __props.heading ? unref(headingId) : void 0,
+        class: normalizeClass(unref(cn)("overflow-hidden p-1 text-foreground", props.class)),
+        "data-slot": "command-group"
+      }, [
+        __props.heading ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          id: unref(headingId),
+          class: "px-2 py-1.5 text-xs font-medium text-muted-foreground",
+          "data-slot": "command-group-heading"
+        }, toDisplayString(__props.heading), 9, _hoisted_2)) : createCommentVNode("", true),
+        renderSlot(_ctx.$slots, "default")
+      ], 10, _hoisted_1)), [
+        [vShow, !unref(ctx).ready.value || unref(ctx).groupHasVisible(unref(groupId))]
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/ui/command/command-group2.vue.js

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

package/dist/components/ui/command/command-input.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    class?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;