@chelone/vue 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,75 @@
+import { defineComponent, openBlock, createElementBlock, createElementVNode, mergeProps, unref } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { useCommand } from "./context.js";
+const _hoisted_1 = {
+  class: "flex h-9 items-center gap-2 border-b px-3",
+  "data-slot": "command-input-wrapper"
+};
+const _hoisted_2 = ["aria-controls", "aria-activedescendant", "value"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ inheritAttrs: false },
+  __name: "command-input",
+  props: {
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const ctx = useCommand();
+    function onKeydown(event) {
+      if (event.isComposing) return;
+      const moves = {
+        ArrowDown: "next",
+        ArrowUp: "prev",
+        Home: "first",
+        End: "last"
+      };
+      if (event.key in moves) {
+        event.preventDefault();
+        ctx.move(moves[event.key]);
+      } else if (event.key === "Enter") {
+        event.preventDefault();
+        ctx.selectActive();
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        _cache[1] || (_cache[1] = createElementVNode("svg", {
+          class: "size-4 shrink-0 opacity-50",
+          viewBox: "0 0 24 24",
+          fill: "none",
+          stroke: "currentColor",
+          "stroke-width": "2",
+          "stroke-linecap": "round",
+          "stroke-linejoin": "round",
+          "aria-hidden": "true"
+        }, [
+          createElementVNode("circle", {
+            cx: "11",
+            cy: "11",
+            r: "8"
+          }),
+          createElementVNode("path", { d: "m21 21-4.3-4.3" })
+        ], -1)),
+        createElementVNode("input", mergeProps(_ctx.$attrs, {
+          type: "text",
+          role: "combobox",
+          autocomplete: "off",
+          "aria-expanded": "true",
+          "aria-controls": unref(ctx).listId,
+          "aria-activedescendant": unref(ctx).activeId.value ?? void 0,
+          value: unref(ctx).search.value,
+          class: unref(cn)(
+            "flex h-10 w-full rounded-md bg-transparent py-3 text-sm outline-hidden placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50",
+            props.class
+          ),
+          "data-slot": "command-input",
+          onInput: _cache[0] || (_cache[0] = ($event) => unref(ctx).setSearch($event.target.value)),
+          onKeydown
+        }), null, 16, _hoisted_2)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

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

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

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

@@ -0,0 +1,23 @@
+type __VLS_Props = {
+    value: string;
+    keywords?: string[];
+    disabled?: boolean;
+    forceMount?: 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, {
+    select: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, 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-item.vue.js

@@ -0,0 +1,72 @@
+import { defineComponent, useId, ref, inject, onMounted, onBeforeUnmount, computed, watch, withDirectives, openBlock, createElementBlock, normalizeClass, unref, renderSlot, vShow } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { useCommand, CommandGroupKey } from "./context.js";
+const _hoisted_1 = ["id", "aria-selected", "aria-disabled", "data-selected", "data-disabled"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "command-item",
+  props: {
+    value: {},
+    keywords: {},
+    disabled: { type: Boolean },
+    forceMount: { type: Boolean },
+    class: {}
+  },
+  emits: ["select"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const ctx = useCommand();
+    const id = useId();
+    const el = ref(null);
+    const entry = {
+      id,
+      groupId: inject(CommandGroupKey, null),
+      el,
+      props,
+      select: () => {
+        if (!props.disabled) emit("select", props.value);
+      }
+    };
+    let unregister;
+    onMounted(() => {
+      unregister = ctx.registerItem(entry);
+    });
+    onBeforeUnmount(() => unregister?.());
+    const visible = computed(() => ctx.isVisible(entry));
+    const active = computed(() => ctx.activeId.value === id);
+    watch(active, (isActive) => {
+      if (isActive) el.value?.scrollIntoView?.({ block: "nearest" });
+    });
+    function onPointerMove() {
+      if (!props.disabled) ctx.setActive(id);
+    }
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createElementBlock("div", {
+        id: unref(id),
+        ref_key: "el",
+        ref: el,
+        role: "option",
+        "aria-selected": active.value,
+        "aria-disabled": __props.disabled || void 0,
+        "data-selected": active.value ? "true" : void 0,
+        "data-disabled": __props.disabled ? "true" : void 0,
+        class: normalizeClass(
+          unref(cn)(
+            "relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden data-[disabled=true]:pointer-events-none data-[selected=true]:bg-accent data-[selected=true]:text-accent-foreground data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*=size-])]:size-4",
+            props.class
+          )
+        ),
+        "data-slot": "command-item",
+        onPointermove: onPointerMove,
+        onClick: _cache[0] || (_cache[0] = ($event) => entry.select())
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 42, _hoisted_1)), [
+        [vShow, visible.value]
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

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

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

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

@@ -0,0 +1,32 @@
+import type { CommandFilter } from "./context.js";
+/** Props for {@link Command}. */
+export interface CommandProps {
+    /** Filter items by the search text. Default `true`. */
+    shouldFilter?: boolean;
+    /** Score `(value, search, keywords)`; `0` hides the item. */
+    filter?: CommandFilter;
+    /** Extra CSS class appended to the root. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<CommandProps & {
+    /** The search text. */
+    modelValue?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<CommandProps & {
+    /** The search text. */
+    modelValue?: string;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    filter: CommandFilter;
+    shouldFilter: 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.vue.js

@@ -0,0 +1,115 @@
+import { defineComponent, useModel, useId, shallowRef, ref, computed, onMounted, onBeforeUnmount, watch, openBlock, createElementBlock, normalizeClass, unref, renderSlot, mergeModels } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { provideCommand, defaultCommandFilter } from "./context.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "command",
+  props: /* @__PURE__ */ mergeModels({
+    shouldFilter: { type: Boolean, default: true },
+    filter: { type: Function, default: void 0 },
+    class: {}
+  }, {
+    "modelValue": { default: "" },
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const search = useModel(__props, "modelValue");
+    const listId = useId();
+    const items = shallowRef([]);
+    const requested = ref(null);
+    const rootRef = ref(null);
+    const ready = ref(false);
+    const orderVersion = ref(0);
+    function score(entry) {
+      const filter = props.filter ?? defaultCommandFilter;
+      return filter(
+        entry.props.value,
+        search.value,
+        entry.props.keywords ? [...entry.props.keywords] : void 0
+      );
+    }
+    function isVisible(entry) {
+      if (!props.shouldFilter || entry.props.forceMount) return true;
+      return score(entry) > 0;
+    }
+    function ordered() {
+      return [...items.value].sort((a, b) => {
+        const [x, y] = [a.el.value, b.el.value];
+        if (!x || !y) return 0;
+        return x.compareDocumentPosition(y) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+      });
+    }
+    function candidates() {
+      return ordered().filter((e) => isVisible(e) && !e.props.disabled);
+    }
+    const activeId = computed(() => {
+      orderVersion.value;
+      const list = candidates();
+      return (list.find((e) => e.id === requested.value) ?? list[0])?.id ?? null;
+    });
+    const visibleCount = computed(
+      () => items.value.filter((e) => isVisible(e)).length
+    );
+    let observer;
+    onMounted(() => {
+      ready.value = true;
+      if (rootRef.value && typeof MutationObserver !== "undefined") {
+        observer = new MutationObserver(() => orderVersion.value++);
+        observer.observe(rootRef.value, { childList: true, subtree: true });
+      }
+    });
+    onBeforeUnmount(() => observer?.disconnect());
+    watch(search, () => requested.value = null, { flush: "sync" });
+    provideCommand({
+      search,
+      setSearch: (value) => {
+        search.value = value;
+      },
+      listId,
+      activeId,
+      setActive: (id) => {
+        requested.value = id;
+      },
+      registerItem: (entry) => {
+        items.value = [...items.value, entry];
+        return () => {
+          items.value = items.value.filter((e) => e !== entry);
+        };
+      },
+      isVisible,
+      ready,
+      visibleCount,
+      groupHasVisible: (groupId) => items.value.some((e) => e.groupId === groupId && isVisible(e)),
+      move: (to) => {
+        const list = candidates();
+        if (list.length === 0) return;
+        const at = list.findIndex((e) => e.id === activeId.value);
+        const last = list.length - 1;
+        const next = to === "first" ? 0 : to === "last" ? last : to === "next" ? at < 0 || at === last ? 0 : at + 1 : at <= 0 ? last : at - 1;
+        requested.value = list[next]?.id ?? null;
+      },
+      selectActive: () => {
+        items.value.find((e) => e.id === activeId.value)?.select();
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "rootRef",
+        ref: rootRef,
+        class: normalizeClass(
+          unref(cn)(
+            "flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground",
+            props.class
+          )
+        ),
+        "data-slot": "command"
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/ui/command/command2.vue.js

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

package/dist/components/ui/command/context.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The `<Command>` context — the non-component core of the dependency-free
+ * command family. The root SFC owns the search text, the registered items and
+ * the active item and `provide`s this contract; the input drives it, items
+ * register against it, and groups and the empty state read visibility from it.
+ */
+import { type ComputedRef, type InjectionKey, type Ref } from "vue";
+/** Scores how well `value` (and its `keywords`) match `search`; `0` is no match. */
+export type CommandFilter = (value: string, search: string, keywords?: string[]) => number;
+/**
+ * The default filter. An empty search matches everything; otherwise the best of
+ * the value and the keywords wins, a case-insensitive substring scoring `1` and a
+ * scattered (in-order) match `0.5`.
+ */
+export declare const defaultCommandFilter: CommandFilter;
+/** What an item hands the root when it registers. */
+export interface CommandItemEntry {
+    id: string;
+    /** The enclosing `<CommandGroup>`'s id, if any. */
+    groupId: string | null;
+    /** The item's element, used to keep keyboard order equal to DOM order. */
+    el: Ref<HTMLElement | null>;
+    /** The item's reactive props. */
+    props: {
+        readonly value: string;
+        readonly keywords?: readonly string[];
+        readonly disabled?: boolean;
+        readonly forceMount?: boolean;
+    };
+    /** Run the item's `select` (a no-op for a disabled item). */
+    select: () => void;
+}
+/** The reactive contract `<Command>` provides to its parts. */
+export interface CommandContext {
+    /** The search text. */
+    search: Ref<string>;
+    setSearch: (value: string) => void;
+    /** The id of the `CommandList`, referenced by the input's `aria-controls`. */
+    listId: string;
+    /** The id of the active item, or `null` when no item is a candidate. */
+    activeId: ComputedRef<string | null>;
+    setActive: (id: string) => void;
+    /** Register an item; returns the unregister function. */
+    registerItem: (entry: CommandItemEntry) => () => void;
+    /** Whether the item passes the filter (or is `forceMount`). */
+    isVisible: (entry: CommandItemEntry) => boolean;
+    /**
+     * Whether the root and its first items have mounted. Items register on mount,
+     * so before this the registry is empty and says nothing about the list.
+     */
+    ready: Ref<boolean>;
+    /** How many registered items show. */
+    visibleCount: ComputedRef<number>;
+    /** Whether any item of the group shows. */
+    groupHasVisible: (groupId: string) => boolean;
+    /** Move the active item; `next` and `prev` wrap. */
+    move: (to: "next" | "prev" | "first" | "last") => void;
+    /** Select the active item. */
+    selectActive: () => void;
+}
+/** The provide/inject key for the command context. */
+export declare const CommandKey: InjectionKey<CommandContext>;
+/** The enclosing `<CommandGroup>`'s id, provided to its items. */
+export declare const CommandGroupKey: InjectionKey<string>;
+/** Provide the command context (called by `<Command>` in `setup`). */
+export declare function provideCommand(ctx: CommandContext): void;
+/** Read the ambient command context. Throws when used outside `<Command>`. */
+export declare function useCommand(): CommandContext;

package/dist/components/ui/command/context.js

@@ -0,0 +1,35 @@
+import { provide, inject } from "vue";
+const defaultCommandFilter = (value, search, keywords = []) => {
+  const needle = search.trim().toLowerCase();
+  if (needle === "") return 1;
+  let best = 0;
+  for (const text of [value, ...keywords]) {
+    const haystack = text.toLowerCase();
+    if (haystack.includes(needle)) return 1;
+    let at = 0;
+    for (const char of haystack) if (char === needle[at]) at++;
+    if (at === needle.length) best = 0.5;
+  }
+  return best;
+};
+const CommandKey = /* @__PURE__ */ Symbol("chelone-command");
+const CommandGroupKey = /* @__PURE__ */ Symbol(
+  "chelone-command-group"
+);
+function provideCommand(ctx) {
+  provide(CommandKey, ctx);
+}
+function useCommand() {
+  const ctx = inject(CommandKey, null);
+  if (!ctx) {
+    throw new Error("useCommand: used outside a <Command> component.");
+  }
+  return ctx;
+}
+export {
+  CommandGroupKey,
+  CommandKey,
+  defaultCommandFilter,
+  provideCommand,
+  useCommand
+};

package/dist/components/ui/command/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The dependency-free command family barrel — the Vue analog of shadcn's
+ * `command` primitive (root + input + list + item + group + empty + separator +
+ * shortcut + dialog). See `command.vue` for the no-cmdk divergence note.
+ */
+export { type CommandProps, default as Command } from "./command.vue.js";
+export { type CommandDialogProps, default as CommandDialog, } from "./command-dialog.vue.js";
+export { default as CommandGroup } from "./command-group.vue.js";
+export { default as CommandInput } from "./command-input.vue.js";
+export { default as CommandItem } from "./command-item.vue.js";
+export { type CommandContext, type CommandFilter, type CommandItemEntry, CommandKey, defaultCommandFilter, provideCommand, useCommand, } from "./context.js";
+export { CommandEmpty, CommandList, CommandSeparator, CommandShortcut, } from "./parts.js";

package/dist/components/ui/command/parts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The structural command parts — thin containers over the command context, the
+ * Vue analog of shadcn's same-named parts. Functional components so the set
+ * lives in one dependency-free module; the stateful parts stay as SFCs.
+ */
+import { type FunctionalComponent } from "vue";
+interface ClassProps {
+    class?: string;
+}
+/** The scrollable `role="listbox"` that holds the items. */
+export declare const CommandList: FunctionalComponent<ClassProps>;
+/** Shown only while no item shows, once the items have had the chance to register. */
+export declare const CommandEmpty: FunctionalComponent<ClassProps>;
+/** A horizontal divider between groups. */
+export declare const CommandSeparator: FunctionalComponent<ClassProps>;
+/** A right-aligned keyboard hint inside an item. */
+export declare const CommandShortcut: FunctionalComponent<ClassProps>;
+export {};

package/dist/components/ui/command/parts.js

@@ -0,0 +1,55 @@
+import { h } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { useCommand } from "./context.js";
+const CommandList = (props, { slots }) => h(
+  "div",
+  {
+    id: useCommand().listId,
+    role: "listbox",
+    "data-slot": "command-list",
+    class: cn(
+      "max-h-[300px] scroll-py-1 overflow-x-hidden overflow-y-auto",
+      props.class
+    )
+  },
+  slots.default?.()
+);
+CommandList.props = ["class"];
+CommandList.displayName = "CommandList";
+const CommandEmpty = (props, { slots }) => useCommand().ready.value && useCommand().visibleCount.value === 0 ? h(
+  "div",
+  {
+    role: "presentation",
+    "data-slot": "command-empty",
+    class: cn("py-6 text-center text-sm", props.class)
+  },
+  slots.default?.()
+) : null;
+CommandEmpty.props = ["class"];
+CommandEmpty.displayName = "CommandEmpty";
+const CommandSeparator = (props) => h("div", {
+  role: "separator",
+  "data-slot": "command-separator",
+  class: cn("-mx-1 h-px bg-border", props.class)
+});
+CommandSeparator.props = ["class"];
+CommandSeparator.displayName = "CommandSeparator";
+const CommandShortcut = (props, { slots }) => h(
+  "span",
+  {
+    "data-slot": "command-shortcut",
+    class: cn(
+      "ml-auto text-xs tracking-widest text-muted-foreground",
+      props.class
+    )
+  },
+  slots.default?.()
+);
+CommandShortcut.props = ["class"];
+CommandShortcut.displayName = "CommandShortcut";
+export {
+  CommandEmpty,
+  CommandList,
+  CommandSeparator,
+  CommandShortcut
+};

package/dist/components/ui/dropdown-menu/context.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The `<DropdownMenu>` open-state context — the non-component core of the
+ * dependency-free dropdown family. The root SFC owns the `open` ref + the root
+ * element ref (for the outside-click check) and `provide`s this contract; the
+ * trigger toggles it, the content renders against it, and items close it on
+ * select. A typed `InjectionKey` keeps every consumer's inject fully typed.
+ */
+import { type InjectionKey, type Ref } from "vue";
+/** The reactive contract `<DropdownMenu>` provides to its parts. */
+export interface DropdownMenuContext {
+    /** Whether the menu content is open. */
+    open: Ref<boolean>;
+    /** The root element ref, used for the outside-click dismissal check. */
+    rootRef: Ref<HTMLElement | null>;
+    /** Set the open state. */
+    setOpen: (value: boolean) => void;
+    /** Toggle the open state (the trigger's click handler). */
+    toggle: () => void;
+}
+/** The provide/inject key for the dropdown-menu context. */
+export declare const DropdownMenuKey: InjectionKey<DropdownMenuContext>;
+/** Provide the dropdown context (called by `<DropdownMenu>` in `setup`). */
+export declare function provideDropdownMenu(ctx: DropdownMenuContext): void;
+/** Read the ambient dropdown context. Throws when used outside `<DropdownMenu>`. */
+export declare function useDropdownMenu(): DropdownMenuContext;

package/dist/components/ui/dropdown-menu/context.js

@@ -0,0 +1,21 @@
+import { provide, inject } from "vue";
+const DropdownMenuKey = /* @__PURE__ */ Symbol(
+  "chelone-dropdown-menu"
+);
+function provideDropdownMenu(ctx) {
+  provide(DropdownMenuKey, ctx);
+}
+function useDropdownMenu() {
+  const ctx = inject(DropdownMenuKey, null);
+  if (!ctx) {
+    throw new Error(
+      "useDropdownMenu: used outside a <DropdownMenu> component."
+    );
+  }
+  return ctx;
+}
+export {
+  DropdownMenuKey,
+  provideDropdownMenu,
+  useDropdownMenu
+};

package/dist/components/ui/dropdown-menu/dropdown-menu-content.vue.d.ts

@@ -0,0 +1,18 @@
+/** Props for {@link DropdownMenuContent}. */
+export interface DropdownMenuContentProps {
+    /** Horizontal alignment against the trigger. Defaults to `start` (left). */
+    align?: "start" | "end";
+    /** Extra class appended to the content panel. */
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DropdownMenuContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DropdownMenuContentProps> & Readonly<{}>, {
+    align: "start" | "end";
+}, {}, {}, {}, 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/dropdown-menu/dropdown-menu-content.vue.js

@@ -0,0 +1,34 @@
+import { defineComponent, computed, unref, openBlock, createElementBlock, normalizeClass, renderSlot, createCommentVNode } from "vue";
+import { cn } from "../../../lib/utils.js";
+import { useDropdownMenu } from "./context.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "dropdown-menu-content",
+  props: {
+    align: { default: "start" },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { open } = useDropdownMenu();
+    const classes = computed(
+      () => cn(
+        "absolute top-full z-50 mt-2 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md",
+        props.align === "end" ? "right-0" : "left-0",
+        props.class
+      )
+    );
+    return (_ctx, _cache) => {
+      return unref(open) ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        class: normalizeClass(classes.value),
+        role: "menu",
+        "data-slot": "dropdown-menu-content"
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 2)) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/ui/dropdown-menu/dropdown-menu-content2.vue.js

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

package/dist/components/ui/dropdown-menu/dropdown-menu-item.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    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, {
+    select: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: (() => any) | undefined;
+}>, {}, {}, {}, {}, 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;
+    };
+};