@youcan/celeste 0.6.29 → 0.6.31

package/dist/es/combobox-anchor.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "./chunks/combobox-anchor.js";
+export {
+  _sfc_main as default
+};

package/dist/es/combobox-empty.js

@@ -0,0 +1,33 @@
+import { defineComponent, computed, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { Z as Zv } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-empty",
+  props: {
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = computed(() => {
+      const { class: _, ...delegated } = props;
+      return delegated;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Zv), mergeProps(delegatedProps.value, {
+        class: unref(clsx)("celeste-dropdown-empty-list", props.class)
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const ComboboxEmpty = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-450bfb63"]]);
+export {
+  ComboboxEmpty as default
+};

package/dist/es/combobox-group.js

@@ -0,0 +1,43 @@
+import { defineComponent, computed, openBlock, createBlock, unref, mergeProps, withCtx, createTextVNode, toDisplayString, createCommentVNode, renderSlot } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { T as qv, Y as Yv } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-group",
+  props: {
+    asChild: { type: Boolean },
+    as: {},
+    class: {},
+    heading: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = computed(() => {
+      const { class: _, ...delegated } = props;
+      return delegated;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(qv), mergeProps(delegatedProps.value, {
+        class: unref(clsx)(props.class, "celeste-dropdown-items-group")
+      }), {
+        default: withCtx(() => [
+          _ctx.heading ? (openBlock(), createBlock(unref(Yv), {
+            key: 0,
+            class: ""
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.heading), 1)
+            ]),
+            _: 1
+          })) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const ComboboxGroup = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-66b5c9e4"]]);
+export {
+  ComboboxGroup as default
+};

package/dist/es/combobox-input.js

@@ -0,0 +1,64 @@
+import { defineComponent, mergeModels, useModel, computed, openBlock, createBlock, unref, mergeProps, withCtx, createVNode, createElementVNode } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { U as Wv } from "./chunks/index.js";
+import TextInput from "./text-input.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-input",
+  props: /* @__PURE__ */ mergeModels({
+    type: {},
+    disabled: { type: Boolean },
+    autoFocus: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {},
+    textInputProps: {},
+    searchable: { type: Boolean }
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const model = useModel(__props, "modelValue");
+    const comboboxInputProps = computed(() => {
+      const { class: _class, textInputProps: _textInputProps, ...rest } = props;
+      return rest;
+    });
+    const textInputProps = computed(() => {
+      return {
+        type: "search",
+        size: "sm",
+        placeholder: "Search",
+        ...props.textInputProps
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Wv), mergeProps(comboboxInputProps.value, {
+        class: unref(clsx)("celeste-dropdown-input", props.class),
+        readonly: !props.searchable,
+        as: "div"
+      }), {
+        default: withCtx(() => [
+          createVNode(TextInput, mergeProps(textInputProps.value, {
+            modelValue: model.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => model.value = $event),
+            readonly: !props.searchable,
+            style: !props.searchable ? "opacity: 0; height: 1px; padding: 0; border: none;" : ""
+          }), {
+            leadingIcon: withCtx(() => _cache[1] || (_cache[1] = [
+              createElementVNode("i", { "i-celeste-search-2-line": "" }, null, -1)
+            ])),
+            _: 1
+          }, 16, ["modelValue", "readonly", "style"])
+        ]),
+        _: 1
+      }, 16, ["class", "readonly"]);
+    };
+  }
+});
+const ComboboxInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-bd59a65e"]]);
+export {
+  ComboboxInput as default
+};

package/dist/es/combobox-item.js

@@ -0,0 +1,110 @@
+import { defineComponent, computed, openBlock, createBlock, unref, mergeProps, withCtx, createElementVNode, normalizeClass, createCommentVNode, createElementBlock, renderSlot, toDisplayString } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { x as xe, X as Qv } from "./chunks/index.js";
+import { _ as _sfc_main$1 } from "./chunks/checkbox.vue_vue_type_style_index_0_lang.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _hoisted_1 = ["aria-disabled"];
+const _hoisted_2 = { class: "celeste-dropdown-item-info" };
+const _hoisted_3 = ["innerHTML"];
+const _hoisted_4 = {
+  key: 0,
+  class: "celeste-dropdown-item-sublabel"
+};
+const _hoisted_5 = {
+  key: 0,
+  class: "celeste-dropdown-item-description"
+};
+const _hoisted_6 = {
+  key: 2,
+  class: "celeste-dropdown-item-suffix"
+};
+const _hoisted_7 = {
+  key: 3,
+  class: "i-celeste-check-fill"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-item",
+  props: {
+    class: {},
+    label: {},
+    size: { default: "sm" },
+    checkbox: { type: Boolean },
+    sublabel: {},
+    description: {},
+    selected: { type: [Boolean, String] },
+    focused: { type: Boolean },
+    value: { type: [String, Number, Boolean, Object] },
+    icon: {},
+    image: {},
+    disabled: { type: Boolean }
+  },
+  emits: ["select"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const delegatedProps = computed(() => {
+      const { class: _, ...delegated } = props;
+      return delegated;
+    });
+    const forwarded = xe(delegatedProps, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Qv), mergeProps(unref(forwarded), {
+        disabled: _ctx.disabled,
+        "as-child": ""
+      }), {
+        default: withCtx(() => [
+          createElementVNode("div", {
+            tabindex: "0",
+            "aria-disabled": _ctx.disabled,
+            class: normalizeClass(unref(clsx)(
+              props.class,
+              "celeste-dropdown-item",
+              { "celeste-dropdown-item-disabled": _ctx.disabled },
+              { "celeste-dropdown-item-selected": _ctx.selected },
+              { "celeste-dropdown-item-focused": _ctx.focused }
+            ))
+          }, [
+            _ctx.checkbox && _ctx.size === "sm" ? (openBlock(), createBlock(_sfc_main$1, {
+              key: 0,
+              checked: _ctx.selected,
+              disabled: _ctx.disabled
+            }, null, 8, ["checked", "disabled"])) : createCommentVNode("", true),
+            _ctx.$slots.prefix ? (openBlock(), createElementBlock("div", {
+              key: 1,
+              class: normalizeClass(unref(clsx)(
+                "celeste-dropdown-item-prefix",
+                `celeste-dropdown-item-prefix-${_ctx.size}`
+              ))
+            }, [
+              renderSlot(_ctx.$slots, "prefix", {}, void 0, true)
+            ], 2)) : createCommentVNode("", true),
+            createElementVNode("div", _hoisted_2, [
+              createElementVNode("div", {
+                class: normalizeClass(unref(clsx)(
+                  "celeste-dropdown-item-header",
+                  `celeste-dropdown-item-header-${_ctx.size}`
+                ))
+              }, [
+                createElementVNode("span", {
+                  class: "celeste-dropdown-item-label",
+                  innerHTML: _ctx.label
+                }, null, 8, _hoisted_3),
+                _ctx.sublabel ? (openBlock(), createElementBlock("span", _hoisted_4, toDisplayString(_ctx.sublabel), 1)) : createCommentVNode("", true)
+              ], 2),
+              _ctx.description && _ctx.size === "lg" ? (openBlock(), createElementBlock("p", _hoisted_5, toDisplayString(_ctx.description), 1)) : createCommentVNode("", true)
+            ]),
+            _ctx.$slots.suffix ? (openBlock(), createElementBlock("div", _hoisted_6, [
+              renderSlot(_ctx.$slots, "suffix", {}, void 0, true)
+            ])) : createCommentVNode("", true),
+            _ctx.selected ? (openBlock(), createElementBlock("i", _hoisted_7)) : createCommentVNode("", true)
+          ], 10, _hoisted_1)
+        ]),
+        _: 3
+      }, 16, ["disabled"]);
+    };
+  }
+});
+const ComboboxItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3c2bd0ae"]]);
+export {
+  ComboboxItem as default
+};

package/dist/es/combobox-list.js

@@ -0,0 +1,63 @@
+import { defineComponent, computed, openBlock, createBlock, unref, withCtx, createVNode, mergeProps, renderSlot } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { x as xe, _ as nm, $ as Xv, a0 as Jv } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-list",
+  props: {
+    forceMount: { type: Boolean },
+    position: { default: "popper" },
+    bodyLock: { type: Boolean },
+    dismissable: { type: Boolean },
+    side: {},
+    sideOffset: { default: 4 },
+    align: { default: "start" },
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    updatePositionStrategy: {},
+    prioritizePosition: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    disableOutsidePointerEvents: { type: Boolean },
+    class: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const delegatedProps = computed(() => {
+      const { class: _, ...delegated } = props;
+      return delegated;
+    });
+    const forwarded = xe(delegatedProps, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(nm), null, {
+        default: withCtx(() => [
+          createVNode(unref(Xv), mergeProps(unref(forwarded), {
+            class: unref(clsx)("celeste-dropdown-content", props.class)
+          }), {
+            default: withCtx(() => [
+              createVNode(unref(Jv), { class: "celeste-dropdown-items-viewport" }, {
+                default: withCtx(() => [
+                  renderSlot(_ctx.$slots, "default", {}, void 0, true)
+                ]),
+                _: 3
+              })
+            ]),
+            _: 3
+          }, 16, ["class"])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const ComboboxList = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-dc6bae8b"]]);
+export {
+  ComboboxList as default
+};

package/dist/es/combobox-root.js

@@ -0,0 +1,41 @@
+import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+import { x as xe, a1 as Hv } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-root",
+  props: {
+    modelValue: {},
+    defaultValue: {},
+    open: { type: Boolean },
+    defaultOpen: { type: Boolean },
+    searchTerm: {},
+    selectedValue: {},
+    multiple: { type: Boolean },
+    disabled: { type: Boolean },
+    name: {},
+    dir: {},
+    filterFunction: { type: Function },
+    displayValue: { type: Function },
+    resetSearchTermOnBlur: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["update:modelValue", "update:open", "update:searchTerm", "update:selectedValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const forwarded = xe(props, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Hv), mergeProps({ class: "celeste-combobox-root" }, unref(forwarded)), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const ComboboxRoot = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-29e14e56"]]);
+export {
+  ComboboxRoot as default
+};

package/dist/es/combobox-separator.js

@@ -0,0 +1,33 @@
+import { defineComponent, computed, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { a2 as tm } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-separator",
+  props: {
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = computed(() => {
+      const { class: _, ...delegated } = props;
+      return delegated;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(tm), mergeProps(delegatedProps.value, {
+        class: unref(clsx)("celeste-dropdown-separator", props.class)
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const ComboboxSeparator = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-987226c9"]]);
+export {
+  ComboboxSeparator as default
+};

package/dist/es/combobox-trigger.js

@@ -0,0 +1,48 @@
+import { defineComponent, computed, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { A as At, a3 as Uv } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-trigger",
+  props: {
+    class: {},
+    size: {},
+    filled: { type: Boolean },
+    type: { default: "normal" },
+    error: { type: Boolean },
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = computed(() => {
+      const { class: _, ...delegated } = props;
+      return delegated;
+    });
+    const forwarded = At(delegatedProps);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Uv), mergeProps(unref(forwarded), {
+        type: "button",
+        tabindex: "0",
+        class: unref(clsx)(
+          "celeste-dropdown-anchor-trigger",
+          `celeste-dropdown-anchor-trigger-size-${props.size}`,
+          `celeste-dropdown-anchor-trigger-type-${props.type}`,
+          { "celeste-dropdown-anchor-trigger-error": props.error },
+          { "celeste-dropdown-anchor-trigger-filled": _ctx.filled },
+          props.class
+        )
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const ComboboxTrigger = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-bddcd2de"]]);
+export {
+  ComboboxTrigger as default
+};

package/dist/es/combobox.js

@@ -0,0 +1,234 @@
+import { defineComponent, computed, openBlock, createBlock, mergeProps, unref, withCtx, createVNode, normalizeClass, createElementBlock, createElementVNode, createCommentVNode, renderSlot, normalizeProps, guardReactiveProps, toDisplayString, createSlots, createTextVNode, Fragment, renderList } from "vue";
+import { x as xe } from "./chunks/index.js";
+import Badge from "./badge.js";
+import { _ as _sfc_main$1 } from "./chunks/combobox-anchor.js";
+import ComboboxEmpty from "./combobox-empty.js";
+import ComboboxGroup from "./combobox-group.js";
+import ComboboxInput from "./combobox-input.js";
+import ComboboxItem from "./combobox-item.js";
+import ComboboxList from "./combobox-list.js";
+import ComboboxRoot from "./combobox-root.js";
+import ComboboxSeparator from "./combobox-separator.js";
+import ComboboxTrigger from "./combobox-trigger.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "celeste-dropdown-anchor-trigger-prefix"
+};
+const _hoisted_2 = { class: "celeste-dropdown-anchor-trigger-prefix-selected" };
+const _hoisted_3 = { key: 1 };
+const _hoisted_4 = ["src"];
+const _hoisted_5 = {
+  key: 1,
+  class: "celeste-dropdown-anchor-trigger-prefix"
+};
+const _hoisted_6 = {
+  key: 2,
+  class: "celeste-dropdown-input"
+};
+const _hoisted_7 = {
+  key: 0,
+  class: "celeste-input-badge"
+};
+const _hoisted_8 = ["src"];
+const __default__ = {
+  inheritAttrs: false
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "combobox",
+  props: {
+    options: {},
+    valueBy: {},
+    labelBy: {},
+    placeholder: { default: "Select" },
+    type: {},
+    size: { default: "md" },
+    emptyLabel: {},
+    badgeProps: {},
+    searchable: { type: Boolean },
+    class: {},
+    modelValue: {},
+    defaultValue: {},
+    open: { type: Boolean },
+    defaultOpen: { type: Boolean },
+    searchTerm: {},
+    selectedValue: {},
+    multiple: { type: Boolean },
+    disabled: { type: Boolean },
+    name: {},
+    dir: {},
+    filterFunction: {},
+    displayValue: {},
+    resetSearchTermOnBlur: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["update:modelValue", "update:open", "update:searchTerm", "update:selectedValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const delegatedProps = computed(() => {
+      const {
+        open,
+        filterFunction: filterFunction2,
+        options,
+        valueBy,
+        labelBy,
+        placeholder,
+        type,
+        size,
+        emptyLabel,
+        badgeProps,
+        searchable,
+        class: _class,
+        ...delegated
+      } = props;
+      return delegated;
+    });
+    const forwarded = xe(delegatedProps, emits);
+    const model = computed(() => props.modelValue);
+    const label = computed(() => {
+      if (!model.value)
+        return props.placeholder;
+      if (Array.isArray(model.value)) {
+        if (model.value.length === 0)
+          return props.placeholder;
+        return model.value.map((item) => props.labelBy ? item[props.labelBy] : item.label).join(", ");
+      }
+      return props.labelBy ? model.value[props.labelBy] : model.value.label;
+    });
+    function isSelected(value) {
+      if (!Array.isArray(props.modelValue) || !props.multiple)
+        return;
+      if (value === void 0 || value === null)
+        return false;
+      return props.modelValue.some((selectedItem) => {
+        const { value: selectedValue } = selectedItem;
+        if (props.valueBy && Object.prototype.hasOwnProperty.call(value, props.valueBy) && Object.prototype.hasOwnProperty.call(selectedValue, props.valueBy)) {
+          return value[props.valueBy] === selectedValue[props.valueBy];
+        }
+        return selectedValue === value;
+      });
+    }
+    function filterFunction(list, searchTerm) {
+      return list.filter((option) => {
+        const { value, label: label2 } = option;
+        if (!value || !label2)
+          return false;
+        if (props.valueBy && typeof value === "object" && props.valueBy in value) {
+          return String(value[props.valueBy]).toLowerCase().includes(searchTerm.toLowerCase()) || label2.toString().toLowerCase().includes(searchTerm.toLowerCase());
+        }
+        return value.toString().toLowerCase().includes(searchTerm.toLowerCase()) || label2.toString().toLowerCase().includes(searchTerm.toLowerCase());
+      });
+    }
+    const mergedBadgeProps = computed(() => ({
+      ...props.badgeProps,
+      disabled: props.disabled
+    }));
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(ComboboxRoot, mergeProps(unref(forwarded), { "filter-function": filterFunction }), {
+        default: withCtx(() => [
+          createVNode(_sfc_main$1, { "as-child": "" }, {
+            default: withCtx(() => [
+              createVNode(ComboboxTrigger, {
+                type: _ctx.type,
+                filled: !!model.value,
+                size: _ctx.size,
+                class: normalizeClass(props.class)
+              }, {
+                default: withCtx(() => [
+                  model.value && !Array.isArray(model.value) && (model.value.icon || model.value.image) ? (openBlock(), createElementBlock("div", _hoisted_1, [
+                    createElementVNode("div", _hoisted_2, [
+                      model.value.icon ? (openBlock(), createElementBlock("i", {
+                        key: 0,
+                        class: normalizeClass(model.value.icon)
+                      }, null, 2)) : createCommentVNode("", true),
+                      model.value.image ? (openBlock(), createElementBlock("div", _hoisted_3, [
+                        renderSlot(_ctx.$slots, "image", normalizeProps(guardReactiveProps({ selected: model.value })), () => [
+                          createElementVNode("img", {
+                            src: model.value.image,
+                            alt: "Selected option",
+                            class: "selected-dropdown-image"
+                          }, null, 8, _hoisted_4)
+                        ], true)
+                      ])) : createCommentVNode("", true)
+                    ])
+                  ])) : _ctx.$slots.prefix ? (openBlock(), createElementBlock("div", _hoisted_5, [
+                    renderSlot(_ctx.$slots, "prefix", { class: "celeste-dropdown-anchor-trigger-prefix-default" }, void 0, true)
+                  ])) : createCommentVNode("", true),
+                  _ctx.type !== "inline" ? (openBlock(), createElementBlock("div", _hoisted_6, [
+                    createElementVNode("span", null, toDisplayString(label.value), 1),
+                    mergedBadgeProps.value && _ctx.badgeProps ? (openBlock(), createElementBlock("span", _hoisted_7, [
+                      createVNode(Badge, normalizeProps(guardReactiveProps(mergedBadgeProps.value)), null, 16)
+                    ])) : createCommentVNode("", true)
+                  ])) : createCommentVNode("", true),
+                  _cache[0] || (_cache[0] = createElementVNode("div", { class: "celeste-dropdown-trigger" }, [
+                    createElementVNode("i", { class: "i-celeste-arrow-down-s-line" })
+                  ], -1))
+                ]),
+                _: 3
+              }, 8, ["type", "filled", "size", "class"])
+            ]),
+            _: 3
+          }),
+          createVNode(ComboboxList, null, {
+            default: withCtx(() => [
+              createElementVNode("div", {
+                class: normalizeClass(["celeste-dropdown-inner-input", { "sr-only": !_ctx.searchable }])
+              }, [
+                createVNode(ComboboxInput, { searchable: _ctx.searchable }, null, 8, ["searchable"]),
+                _ctx.searchable ? (openBlock(), createBlock(ComboboxSeparator, { key: 0 })) : createCommentVNode("", true)
+              ], 2),
+              createVNode(ComboboxEmpty, null, createSlots({ _: 2 }, [
+                _ctx.emptyLabel ? {
+                  name: "default",
+                  fn: withCtx(() => [
+                    createTextVNode(toDisplayString(_ctx.emptyLabel), 1)
+                  ]),
+                  key: "0"
+                } : void 0
+              ]), 1024),
+              createVNode(ComboboxGroup, null, {
+                default: withCtx(() => [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(props.options, (option) => {
+                    return openBlock(), createBlock(ComboboxItem, {
+                      key: option.label,
+                      label: option.label,
+                      sublabel: option.sublabel,
+                      description: option.description,
+                      checkbox: props.multiple,
+                      value: option,
+                      selected: isSelected(option.value)
+                    }, {
+                      prefix: withCtx(() => [
+                        option.icon ? (openBlock(), createElementBlock("i", {
+                          key: 0,
+                          class: normalizeClass(option.icon)
+                        }, null, 2)) : createCommentVNode("", true),
+                        option.image ? (openBlock(), createElementBlock("img", {
+                          key: 1,
+                          src: option.image,
+                          alt: "option",
+                          class: "celeste-dropdown-item-image"
+                        }, null, 8, _hoisted_8)) : createCommentVNode("", true)
+                      ]),
+                      _: 2
+                    }, 1032, ["label", "sublabel", "description", "checkbox", "value", "selected"]);
+                  }), 128))
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const combobox = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e3715243"]]);
+export {
+  combobox as default
+};