@destyler/combobox 0.0.6 → 0.0.7-beta.2

package/dist/component.cjs

@@ -1,1101 +0,0 @@
-'use strict';
-
-const vue = require('vue');
-const primitive = require('@destyler/primitive');
-const composition = require('@destyler/composition');
-const popper = require('@destyler/popper');
-const component$2 = require('@destyler/popper/component');
-const shared = require('@destyler/shared');
-const component = require('@destyler/visually-hidden/component');
-const composition$1 = require('@destyler/collection/composition');
-const collection = require('@destyler/collection');
-const dismissableLayer = require('@destyler/dismissable-layer');
-const component$1 = require('@destyler/dismissable-layer/component');
-const directives = require('@destyler/directives');
-const presence = require('@destyler/presence');
-const teleport = require('@destyler/teleport');
-
-const comboboxAnchorProps = {
-  ...primitive.primitiveProps
-};
-const ComboboxAnchor = vue.defineComponent({
-  name: "DestylerComboboxAnchor",
-  props: comboboxAnchorProps,
-  setup() {
-    const { forwardRef } = composition.useForwardExpose();
-    return {
-      forwardRef
-    };
-  },
-  render() {
-    return vue.h(popper.PopperAnchor, {
-      asChild: true
-    }, () => {
-      return vue.h(primitive.Primitive, vue.mergeProps(this.$attrs, {
-        ref: (el) => this.forwardRef(el),
-        as: this.$props.as,
-        asChild: this.$props.asChild
-      }), {
-        default: () => this.$slots.default?.()
-      });
-    });
-  }
-});
-
-const comboboxRootProps = {
-  ...primitive.primitiveProps,
-  /**
-   * The controlled value of the Combobox. Can be binded-with with `v-model`.
-   *
-   * @default undefined
-   */
-  modelValue: {
-    type: [String, Number, Boolean, Object, Array],
-    required: false,
-    default: void 0
-  },
-  /**
-   * The value of the combobox when initially rendered.
-   * Use when you do not need to control the state of the Combobox
-   *
-   * @default undefined
-   */
-  defaultValue: {
-    type: [String, Number, Boolean, Object, Array],
-    required: false,
-    default: void 0
-  },
-  /**
-   * The controlled open state of the Combobox. Can be binded-with with `v-model:open`.
-   *
-   * @default undefined
-   */
-  open: {
-    type: Boolean,
-    required: false,
-    default: void 0
-  },
-  /**
-   * The open state of the combobox when it is initially rendered.
-   * Use when you do not need to control its open state.
-   */
-  defaultOpen: {
-    type: Boolean,
-    required: false
-  },
-  /**
-   * The controlled search term of the Combobox.
-   * Can be binded-with with `v-model:searchTerm`.
-   */
-  searchTerm: {
-    type: String,
-    required: false
-  },
-  /**
-   * Whether multiple options can be selected or not.
-   *
-   * @default false
-   */
-  multiple: {
-    type: Boolean,
-    required: false,
-    default: false
-  },
-  /**
-   * When `true`, prevents the user from interacting with Combobox.
-   *
-   * @default false
-   */
-  disabled: {
-    type: Boolean,
-    required: false,
-    default: false
-  },
-  /**
-   * The name of the Combobox. Submitted with its owning form as part of a name/value pair.
-   */
-  name: {
-    type: String,
-    required: false
-  },
-  /**
-   * The reading direction of the combobox when applicable.
-   */
-  dir: {
-    type: String,
-    required: false
-  },
-  /**
-   * The custom filter function for filtering `ComboboxItem`.
-   */
-  filterFunction: {
-    type: Function,
-    required: false
-  },
-  /**
-   * The display value of input for selected item. Does not work with `multiple`.
-   */
-  displayValue: {
-    type: Function,
-    required: false
-  }
-};
-const comboboxRootEmits = {
-  /**
-   * Event handler called when the value changes.
-   */
-  "update:modelValue": (_value) => true,
-  /**
-   * Event handler called when the open state of the combobox changes.
-   */
-  "update:open": (_value) => true,
-  /**
-   * Event handler called when the searchTerm of the combobox changes.
-   */
-  "update:searchTerm": (_value) => true
-};
-const [injectComboboxRootContext, provideComboboxRootContext] = shared.createContext("DestylerComboboxRoot");
-const ComboboxRoot = vue.defineComponent({
-  name: "DestylerComboboxRoot",
-  props: comboboxRootProps,
-  emits: comboboxRootEmits,
-  slots: Object,
-  setup(props, { emit }) {
-    const { multiple, disabled, dir: propDir } = vue.toRefs(props);
-    const dir = composition.useDirection(propDir);
-    const searchTerm = composition.useVModel(props, "searchTerm", emit, {
-      defaultValue: "",
-      passive: props.searchTerm === void 0
-    });
-    const modelValue = composition.useVModel(props, "modelValue", emit, {
-      defaultValue: props.defaultValue ?? multiple.value ? [] : void 0,
-      passive: props.modelValue === void 0,
-      deep: true
-    });
-    const open = composition.useVModel(props, "open", emit, {
-      defaultValue: props.defaultOpen,
-      passive: props.open === void 0
-    });
-    const selectedValue = vue.ref();
-    const inputElement = vue.ref();
-    const contentElement = vue.ref();
-    const { forwardRef, currentElement: parentElement } = composition.useForwardExpose();
-    const { getItems, reactiveItems, itemMapSize } = composition$1.createCollection("data-destyler-combobox-item");
-    const isUserInputted = vue.ref(false);
-    async function onOpenChange(val) {
-      open.value = val;
-      await vue.nextTick();
-      if (val) {
-        if (modelValue.value) {
-          if (Array.isArray(modelValue.value) && multiple.value)
-            selectedValue.value = getItems().find((i) => i.ref?.dataset?.state === "checked")?.value;
-          else
-            selectedValue.value = modelValue.value;
-        }
-        inputElement.value?.focus();
-        scrollSelectedValueIntoView();
-      } else {
-        isUserInputted.value = false;
-        resetSearchTerm();
-      }
-    }
-    function onValueChange(val) {
-      if (Array.isArray(modelValue.value) && multiple.value) {
-        const index = modelValue.value.findIndex((i) => shared.isEqual(i, val));
-        index === -1 ? modelValue.value.push(val) : modelValue.value.splice(index, 1);
-      } else {
-        modelValue.value = val;
-        onOpenChange(false);
-      }
-    }
-    const options = vue.ref([]);
-    vue.watch(() => itemMapSize.value, () => {
-      options.value = getItems().map((i) => i.value);
-    }, { immediate: true });
-    const filteredOptions = vue.computed(() => {
-      if (isUserInputted.value) {
-        if (props.filterFunction)
-          return props.filterFunction(options.value, searchTerm.value);
-        const optionsWithTypeString = options.value.filter((i) => typeof i === "string");
-        if (optionsWithTypeString.length)
-          return optionsWithTypeString.filter((i) => i.toLowerCase().includes(searchTerm.value?.toLowerCase()));
-      }
-      return options.value;
-    });
-    function resetSearchTerm() {
-      if (!multiple.value && modelValue.value && !Array.isArray(modelValue.value)) {
-        if (props.displayValue)
-          searchTerm.value = props.displayValue(modelValue.value);
-        else if (typeof modelValue.value !== "object")
-          searchTerm.value = modelValue.value.toString();
-        else
-          searchTerm.value = "";
-      } else {
-        searchTerm.value = "";
-      }
-    }
-    const activeIndex = vue.computed(() => filteredOptions.value.findIndex((i) => shared.isEqual(i, selectedValue.value)));
-    const selectedElement = vue.computed(() => {
-      return reactiveItems.value.find((i) => i.value === selectedValue.value)?.ref;
-    });
-    const stringifiedModelValue = vue.computed(() => JSON.stringify(modelValue.value));
-    vue.watch(stringifiedModelValue, async () => {
-      await vue.nextTick();
-      await vue.nextTick();
-      resetSearchTerm();
-    }, { immediate: true });
-    vue.watch(() => filteredOptions.value.length, async (length) => {
-      await vue.nextTick();
-      await vue.nextTick();
-      if (length && activeIndex.value === -1)
-        selectedValue.value = filteredOptions.value[0];
-    });
-    const isFormControl = composition.useFormControl(parentElement);
-    function scrollSelectedValueIntoView() {
-      if (selectedElement.value instanceof Element)
-        selectedElement.value.scrollIntoView({ block: "nearest" });
-    }
-    provideComboboxRootContext({
-      searchTerm,
-      modelValue,
-      onValueChange,
-      isUserInputted,
-      multiple,
-      disabled,
-      open,
-      onOpenChange,
-      filteredOptions,
-      contentId: "",
-      inputElement,
-      onInputElementChange: (val) => inputElement.value = val,
-      onInputNavigation: async (val) => {
-        const index = activeIndex.value;
-        if (index === 0 && val === "up" || index === filteredOptions.value.length - 1 && val === "down")
-          return;
-        if (index === -1 && filteredOptions.value.length || val === "home")
-          selectedValue.value = filteredOptions.value[0];
-        else if (val === "end")
-          selectedValue.value = filteredOptions.value[filteredOptions.value.length - 1];
-        else
-          selectedValue.value = filteredOptions.value[val === "up" ? index - 1 : index + 1];
-        scrollSelectedValueIntoView();
-      },
-      onInputEnter: async () => {
-        if (filteredOptions.value.length && selectedValue.value && selectedElement.value instanceof Element)
-          selectedElement.value?.click();
-      },
-      selectedValue,
-      onSelectedValueChange: (val) => selectedValue.value = val,
-      parentElement,
-      contentElement,
-      onContentElementChange: (val) => contentElement.value = val
-    });
-    return {
-      forwardRef,
-      isFormControl,
-      open,
-      modelValue,
-      dir
-    };
-  },
-  render() {
-    return vue.h(popper.PopperRoot, null, {
-      default: () => {
-        return vue.h(primitive.Primitive, vue.mergeProps(this.$attrs, {
-          ref: (el) => this.forwardRef(el),
-          style: {
-            pointerEvents: this.open ? "auto" : void 0
-          },
-          as: this.$props.as,
-          asChild: this.$props.asChild,
-          dir: this.dir
-        }), {
-          default: () => {
-            return [
-              this.$slots.default?.({ open: this.open, modelValue: this.modelValue }),
-              this.isFormControl && this.$props.name ? vue.h(component.VisuallyHiddenInput, {
-                name: this.$props.name,
-                value: this.modelValue
-              }) : null
-            ];
-          }
-        });
-      }
-    });
-  }
-});
-
-const comboboxContentImplProps = {
-  ...dismissableLayer.dismissableLayerProps,
-  ...popper.popperContentProps,
-  /**
-   * The positioning mode to use, <br>
-   * `inline` is the default and you can control the position using CSS. <br>
-   * `popper` positions content in the same way as our other primitives, for example `Popover` or `DropdownMenu`.
-   *
-   * @default inline
-   */
-  position: {
-    type: String,
-    required: false,
-    default: "inline"
-  },
-  /**
-   * The document.body will be lock, and scrolling will be disabled.
-   */
-  bodyLock: {
-    type: Boolean,
-    required: false
-  },
-  /**
-   * Allow component to be dismissableLayer.
-   *
-   * @default true
-   */
-  dismissable: {
-    type: Boolean,
-    required: false,
-    default: true
-  }
-};
-const comboboxContentImplEmits = {
-  ...component$1.dismissableLayerEmits
-};
-const [injectComboboxContentContext, provideComboboxContentContext] = shared.createContext("DestylerComboboxContent");
-const ComboboxContentImpl = vue.defineComponent({
-  name: "DestylerComboboxContentImpl",
-  props: comboboxContentImplProps,
-  emits: comboboxContentImplEmits,
-  setup(props) {
-    const { position } = vue.toRefs(props);
-    const rootContext = injectComboboxRootContext();
-    composition.useBodyScrollLock(props.bodyLock);
-    const { forwardRef, currentElement } = composition.useForwardExpose();
-    composition.useHideOthers(currentElement);
-    const pickedProps = vue.computed(() => {
-      if (props.position === "popper")
-        return props;
-      else
-        return {};
-    });
-    const forwardedProps = composition.useForwardProps(pickedProps.value);
-    function handleLeave() {
-      rootContext.onSelectedValueChange("");
-    }
-    vue.onMounted(() => {
-      rootContext.onContentElementChange(currentElement.value);
-    });
-    const popperStyle = {
-      "boxSizing": "border-box",
-      "--destyler-combobox-content-transform-origin": "var(--destyler-popper-transform-origin)",
-      "--destyler-combobox-content-available-width": "var(--destyler-popper-available-width)",
-      "--destyler-combobox-content-available-height": "var(--destyler-popper-available-height)",
-      "--destyler-combobox-trigger-width": "var(--destyler-popper-anchor-width)",
-      "--destyler-combobox-trigger-height": "var(--destyler-popper-anchor-height)"
-    };
-    provideComboboxContentContext({ position });
-    return {
-      rootContext,
-      popperStyle,
-      forwardedProps,
-      pickedProps,
-      forwardRef,
-      handleLeave
-    };
-  },
-  render() {
-    return vue.h(collection.CollectionSlot, null, {
-      default: () => {
-        return [
-          this.$props.dismissable ? vue.h(dismissableLayer.DismissableLayer, {
-            asChild: true,
-            disableOutsidePointerEvents: this.$props.disableOutsidePointerEvents,
-            onDismiss: () => {
-              this.rootContext.onOpenChange(false);
-            },
-            onFocusOutside: (event) => {
-              if (this.rootContext.parentElement.value?.contains(event.target))
-                event.preventDefault();
-              this.$emit("focusOutside", event);
-            },
-            onInteractOutside: (event) => {
-              this.$emit("interactOutside", event);
-            },
-            onEscapeKeyDown: (event) => {
-              this.$emit("escapeKeyDown", event);
-            },
-            onPointerDownOutside: (event) => {
-              if (this.rootContext.parentElement.value?.contains(event.target))
-                event.preventDefault();
-              this.$emit("pointerDownOutside", event);
-            }
-          }, {
-            default: () => {
-              return vue.withDirectives(vue.h(this.$props.position === "popper" ? popper.PopperContent : primitive.Primitive, vue.mergeProps(this.$attrs, this.forwardedProps, {
-                "ref": (el) => this.forwardRef(el),
-                "role": "listbox",
-                "data-state": this.rootContext.open.value ? "open" : "closed",
-                "style": {
-                  display: "flex",
-                  flexDirection: "column",
-                  outline: "none",
-                  ...this.$props.position === "popper" ? this.popperStyle : {}
-                },
-                "onPointerleave": () => {
-                  this.handleLeave();
-                }
-              }), {
-                default: () => this.$slots.default?.()
-              }), [
-                [directives.BindOnceDirective, { id: this.rootContext.contentId }]
-              ]);
-            }
-          }) : vue.withDirectives(vue.h(this.$props.position === "popper" ? popper.PopperContent : primitive.Primitive, vue.mergeProps(this.$attrs, this.pickedProps, {
-            "ref": (el) => this.forwardRef(el),
-            "role": "listbox",
-            "data-state": this.rootContext.open.value ? "open" : "closed",
-            "style": {
-              display: "flex",
-              flexDirection: "column",
-              outline: "none",
-              ...this.$props.position === "popper" ? this.popperStyle : {}
-            },
-            "onPointerleave": () => {
-              this.handleLeave();
-            }
-          }), {
-            default: () => this.$slots.default?.()
-          }), [
-            [directives.BindOnceDirective, { id: this.rootContext.contentId }]
-          ])
-        ];
-      }
-    });
-  }
-});
-
-const comboboxArrowProps = {
-  ...component$2.popperArrowProps
-};
-const ComboboxArrow = vue.defineComponent({
-  name: "DestylerComboboxArrow",
-  props: comboboxArrowProps,
-  setup() {
-    composition.useForwardExpose();
-    const rootContext = injectComboboxRootContext();
-    const contentContext = injectComboboxContentContext();
-    return {
-      rootContext,
-      contentContext
-    };
-  },
-  render() {
-    if (this.rootContext.open.value && this.contentContext.position.value === "popper")
-      return vue.h(popper.PopperArrow, this.$props, () => this.$slots.default?.());
-    else
-      return null;
-  }
-});
-
-const comboboxCancelProps = {
-  ...primitive.primitiveProps,
-  /**
-   * @default button
-   */
-  as: {
-    ...primitive.primitiveProps.as,
-    default: "button"
-  }
-};
-const ComboboxCancel = vue.defineComponent({
-  name: "DestylerComboboxCancel",
-  props: comboboxCancelProps,
-  setup() {
-    composition.useForwardExpose();
-    const rootContext = injectComboboxRootContext();
-    function handleClick() {
-      rootContext.searchTerm.value = "";
-      rootContext.inputElement.value?.focus();
-    }
-    return {
-      rootContext,
-      handleClick
-    };
-  },
-  render() {
-    return vue.h(primitive.Primitive, vue.mergeProps(this.$props, {
-      type: this.$props.as === "button" ? "button" : void 0,
-      tabindex: "-1",
-      onClick: () => {
-        this.handleClick();
-      }
-    }), () => this.$slots.default?.());
-  }
-});
-
-const comboboxContentProps = {
-  ...comboboxContentImplProps,
-  /**
-   * Used to force mounting when more control is needed.
-   * Useful when controlling animation with Vue animation libraries.
-   */
-  forceMount: {
-    type: Boolean,
-    required: false
-  }
-};
-const comboboxContentEmits = {
-  ...comboboxContentImplEmits
-};
-const ComboboxContent = vue.defineComponent({
-  name: "DestylerComboboxContent",
-  props: comboboxContentProps,
-  emits: comboboxContentEmits,
-  setup(props, { emit }) {
-    const forwarded = composition.useForwardPropsEmits(props, emit);
-    const { forwardRef } = composition.useForwardExpose();
-    const rootContext = injectComboboxRootContext();
-    rootContext.contentId || (rootContext.contentId = composition.useId(void 0, "destyler-combobox-content"));
-    return {
-      forwardRef,
-      forwarded,
-      rootContext
-    };
-  },
-  render() {
-    return vue.h(presence.Presence, {
-      present: this.$props.forceMount || this.rootContext.open.value
-    }, () => vue.h(ComboboxContentImpl, vue.mergeProps(this.$attrs, this.forwarded, {
-      ref: (el) => this.forwardRef(el)
-    }), () => this.$slots.default?.()));
-  }
-});
-
-const comboboxEmptyProps = {
-  ...primitive.primitiveProps
-};
-const ComboboxEmpty = vue.defineComponent({
-  name: "DestylerComboboxEmpty",
-  props: comboboxEmptyProps,
-  setup() {
-    composition.useForwardExpose();
-    const rootContext = injectComboboxRootContext();
-    const isEmpty = vue.computed(() => rootContext.filteredOptions.value.length === 0);
-    return {
-      rootContext,
-      isEmpty
-    };
-  },
-  render() {
-    if (this.isEmpty) {
-      return vue.h(primitive.Primitive, this.$props, {
-        default: () => this.$slots.default ? this.$slots.default?.() : "No options"
-      });
-    }
-  }
-});
-
-const comboboxGroupProps = {
-  ...primitive.primitiveProps
-};
-const [injectComboboxGroupContext, provideComboboxGroupContext] = shared.createContext("DestylerComboboxGroup");
-const ComboboxGroup = vue.defineComponent({
-  name: "DestylerComboboxGroup",
-  props: comboboxGroupProps,
-  setup() {
-    const { currentRef, currentElement } = composition.useForwardExpose();
-    const id = composition.useId(void 0, "destyler-combobox-group");
-    const rootContext = injectComboboxRootContext();
-    const hasOptions = vue.ref(false);
-    function checkCollectionItem() {
-      if (!currentElement.value)
-        return;
-      const collectionItem = currentElement.value.querySelectorAll("[data-destyler-combobox-item]:not([data-hidden])");
-      hasOptions.value = !!collectionItem.length;
-    }
-    composition.useMutationObserver(currentElement, () => {
-      checkCollectionItem();
-    }, {
-      childList: true
-    });
-    vue.watch(() => rootContext.searchTerm.value, () => {
-      vue.nextTick(() => {
-        checkCollectionItem();
-      });
-    }, {
-      immediate: true
-    });
-    provideComboboxGroupContext({
-      id
-    });
-    return {
-      currentRef,
-      hasOptions,
-      id
-    };
-  },
-  render() {
-    return vue.h(primitive.Primitive, vue.mergeProps(this.$props, {
-      "ref": "currentRef",
-      "role": "group",
-      "aria-labelledby": this.id,
-      ...this.hasOptions ? {} : { style: { display: "none" } }
-    }), {
-      default: () => this.$slots.default?.()
-    });
-  }
-});
-
-const comboboxInputProps = {
-  ...primitive.primitiveProps,
-  /**
-   * @default input
-   */
-  as: {
-    ...primitive.primitiveProps.as,
-    default: "input"
-  },
-  /**
-   * Native input type
-   *
-   * @default text
-   */
-  type: {
-    type: String,
-    required: false,
-    default: "text"
-  },
-  /**
-   * When `true`, prevents the user from interacting with item
-   */
-  disabled: {
-    type: Boolean,
-    required: false
-  },
-  /**
-   * Focus on element when mounted.
-   *
-   * @default false
-   */
-  autoFocus: {
-    type: Boolean,
-    required: false
-  }
-};
-const ComboboxInput = vue.defineComponent({
-  name: "DestylerComboboxInput",
-  props: comboboxInputProps,
-  setup(props) {
-    const rootContext = injectComboboxRootContext();
-    const { forwardRef, currentElement } = composition.useForwardExpose();
-    vue.onMounted(() => {
-      const inputEl = currentElement.value.nodeName === "INPUT" ? currentElement.value : currentElement.value.querySelector("input");
-      if (!inputEl)
-        return;
-      rootContext.onInputElementChange(inputEl);
-      setTimeout(() => {
-        if (props.autoFocus)
-          inputEl?.focus();
-      }, 1);
-    });
-    const disabled = vue.computed(() => props.disabled || rootContext.disabled.value || false);
-    function handleKeyDown(ev) {
-      if (!rootContext.open.value)
-        rootContext.onOpenChange(true);
-      else
-        rootContext.onInputNavigation(ev.key === "ArrowUp" ? "up" : "down");
-    }
-    function handleHomeEnd(ev) {
-      if (!rootContext.open.value)
-        return;
-      rootContext.onInputNavigation(ev.key === "Home" ? "home" : "end");
-    }
-    function handleInput(event) {
-      rootContext.searchTerm.value = event.target?.value;
-      if (!rootContext.open.value)
-        rootContext.onOpenChange(true);
-      rootContext.isUserInputted.value = true;
-    }
-    return {
-      disabled,
-      rootContext,
-      forwardRef,
-      handleInput,
-      handleKeyDown,
-      handleHomeEnd
-    };
-  },
-  render() {
-    return vue.h(primitive.Primitive, {
-      "ref": (el) => this.forwardRef(el),
-      "as": this.$props.as,
-      "asChild": this.$props.asChild,
-      "type": this.$props.type,
-      "disabled": this.disabled,
-      "value": this.rootContext.searchTerm.value,
-      "aria-expanded": this.rootContext.open.value,
-      "aria-controls": this.rootContext.contentId,
-      "aria-disabled": this.disabled ?? void 0,
-      "aria-autocomplete": "list",
-      "role": "combobox",
-      "autocomplete": "false",
-      "onInput": (event) => {
-        this.handleInput(event);
-      },
-      "onKeydown": vue.withKeys((event) => {
-        switch (event.key) {
-          case "ArrowUp":
-          case "ArrowDown":
-            event.preventDefault();
-            this.handleKeyDown(event);
-            break;
-          case "Home":
-          case "End":
-            event.preventDefault();
-            this.handleHomeEnd(event);
-            break;
-          case "Enter":
-            this.rootContext.onInputEnter();
-            break;
-        }
-      }, ["down", "up", "enter", "home", "end"])
-    }, {
-      default: () => this.$slots.default?.()
-    });
-  }
-});
-
-const COMBOBOX_SELECT = "combobox.select";
-const comboboxItemProps = {
-  ...primitive.primitiveProps,
-  /**
-   * The value given as data when submitted with a `name`.
-   */
-  value: {
-    type: [String, Number, Boolean, Object],
-    required: true
-  },
-  /**
-   * When true, prevents the user from interacting with the `item`.
-   */
-  disabled: {
-    type: Boolean,
-    required: false
-  }
-};
-const comboboxItemEmits = {
-  /**
-   * Event handler called when the selecting item. <br>
-   * It can be prevented by calling `event.preventDefault`.
-   */
-  select: (_ev) => true
-};
-const [injectComboboxItemContext, provideComboboxItemContext] = shared.createContext("DestylerComboboxItem");
-const ComboboxItem = vue.defineComponent({
-  name: "DestylerComboboxItem",
-  props: comboboxItemProps,
-  emits: comboboxItemEmits,
-  setup(props, { emit }) {
-    const { disabled } = vue.toRefs(props);
-    const rootContext = injectComboboxRootContext();
-    injectComboboxGroupContext({ id: "", options: vue.ref([]) });
-    const { forwardRef } = composition.useForwardExpose();
-    const isSelected = vue.computed(
-      () => rootContext.multiple.value && Array.isArray(rootContext.modelValue.value) ? rootContext.modelValue.value?.some((val) => shared.isEqual(val, props.value)) : shared.isEqual(rootContext.modelValue?.value, props.value)
-    );
-    const isFocused = vue.computed(() => shared.isEqual(rootContext.selectedValue.value, props.value));
-    const textId = composition.useId(void 0, "destyler-combobox-item");
-    const isInOption = vue.computed(() => rootContext.isUserInputted.value ? rootContext.searchTerm.value === "" || !!rootContext.filteredOptions.value.find((i) => shared.isEqual(i, props.value)) : true);
-    async function handleSelect(ev) {
-      emit("select", ev);
-      if (ev?.defaultPrevented)
-        return;
-      if (!disabled.value && ev)
-        rootContext.onValueChange(props.value);
-    }
-    function handleSelectCustomEvent(ev) {
-      if (!ev)
-        return;
-      const eventDetail = { originalEvent: ev, value: props.value };
-      shared.handleAndDispatchCustomEvent(COMBOBOX_SELECT, handleSelect, eventDetail);
-    }
-    async function handlePointerMove(event) {
-      await vue.nextTick();
-      if (event.defaultPrevented)
-        return;
-      rootContext.onSelectedValueChange(props.value);
-    }
-    if (props.value === "") {
-      throw new Error(
-        "A <DestylerSelectItem /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder."
-      );
-    }
-    provideComboboxItemContext({
-      isSelected
-    });
-    return {
-      forwardRef,
-      textId,
-      isFocused,
-      isSelected,
-      isInOption,
-      handleSelectCustomEvent,
-      handlePointerMove
-    };
-  },
-  render() {
-    return vue.h(collection.CollectionItem, null, {
-      default: () => {
-        return vue.h(primitive.Primitive, {
-          "ref": (el) => this.forwardRef(el),
-          "role": "option",
-          "tabindex": "-1",
-          "aria-labelledby": this.textId,
-          "data-highlighted": this.isFocused ? "" : void 0,
-          "aria-selected": this.isSelected,
-          "data-state": this.isSelected ? "checked" : "unchecked",
-          "aria-disabled": this.$props.disabled || void 0,
-          "data-disabled": this.$props.disabled ? "" : void 0,
-          "as": this.$props.as,
-          "asChild": this.$props.asChild,
-          "data-hidden": !this.isInOption ? true : void 0,
-          "onClick": (event) => {
-            this.handleSelectCustomEvent(event);
-          },
-          "onPointermove": (event) => {
-            this.handlePointerMove(event);
-          },
-          ...this.isInOption ? {} : { style: { display: "none" } }
-        }, {
-          default: () => this.$slots.default ? this.$slots.default?.() : this.$props.value
-        });
-      }
-    });
-  }
-});
-
-const comboboxItemIndicatorProps = {
-  ...primitive.primitiveProps,
-  /**
-   * @default span
-   */
-  as: {
-    ...primitive.primitiveProps.as,
-    default: "span"
-  }
-};
-const ComboboxItemIndicator = vue.defineComponent({
-  name: "DestylerComboboxItemIndicator",
-  props: comboboxItemIndicatorProps,
-  setup() {
-    composition.useForwardExpose();
-    const itemContext = injectComboboxItemContext();
-    return {
-      itemContext
-    };
-  },
-  render() {
-    if (this.itemContext.isSelected.value) {
-      return vue.h(primitive.Primitive, vue.mergeProps(this.$props, {
-        "aria-hidden": ""
-      }), {
-        default: () => this.$slots.default?.()
-      });
-    }
-  }
-});
-
-const comboboxLabelProps = {
-  ...primitive.primitiveProps,
-  /**
-   * The id of the element the label is associated with.
-   */
-  for: {
-    type: String,
-    required: false
-  }
-};
-const ComboboxLabel = vue.defineComponent({
-  name: "DestylerComboboxLabel",
-  props: comboboxLabelProps,
-  setup() {
-    composition.useForwardExpose();
-    const groupContext = injectComboboxGroupContext({ id: "" });
-    return {
-      groupContext
-    };
-  },
-  render() {
-    return vue.withDirectives(vue.h(primitive.Primitive, this.$props, {
-      default: () => this.$slots.default?.()
-    }), [
-      [directives.BindOnceDirective, { id: this.groupContext.id }]
-    ]);
-  }
-});
-
-const comboboxPortalProps = {
-  ...teleport.teleportPrimitiveProps
-};
-const ComboboxPortal = vue.defineComponent({
-  name: "DestylerComboboxPortal",
-  props: comboboxPortalProps,
-  render() {
-    return vue.h(teleport.TeleportPrimitive, this.$props, {
-      default: () => this.$slots.default?.()
-    });
-  }
-});
-
-const comboboxSeparatorProps = {
-  ...primitive.primitiveProps
-};
-const ComboboxSeparator = vue.defineComponent({
-  name: "DestylerComboboxSeparator",
-  props: comboboxSeparatorProps,
-  setup() {
-    composition.useForwardExpose();
-  },
-  render() {
-    return vue.h(primitive.Primitive, vue.mergeProps(this.$props, {
-      "aria-hidden": ""
-    }), () => this.$slots.default?.());
-  }
-});
-
-const comboboxTriggerProps = {
-  ...primitive.primitiveProps,
-  /**
-   * @default button
-   */
-  as: {
-    ...primitive.primitiveProps.as,
-    default: "button"
-  },
-  /**
-   * When `true`, prevents the user from interacting with item.
-   */
-  disabled: {
-    type: Boolean,
-    required: false
-  }
-};
-const ComboboxTrigger = vue.defineComponent({
-  name: "DestylerComboboxTrigger",
-  props: comboboxTriggerProps,
-  setup(props) {
-    composition.useForwardExpose();
-    const rootContext = injectComboboxRootContext();
-    const disabled = vue.computed(() => props.disabled || rootContext.disabled.value || false);
-    return {
-      rootContext,
-      disabled
-    };
-  },
-  render() {
-    return vue.h(primitive.Primitive, vue.mergeProps(this.$props, {
-      "type": this.$props.as === "button" ? "button" : void 0,
-      "tabindex": "-1",
-      "aria-label": "Show popup",
-      "aria-haspopup": "listbox",
-      "aria-expanded": this.rootContext.open.value,
-      "aria-controls": this.rootContext.contentId,
-      "data-state": this.rootContext.open.value ? "open" : "closed",
-      "disabled": this.disabled,
-      "data-disabled": this.disabled ? "" : void 0,
-      "aria-disabled": this.disabled ?? void 0,
-      "onClick": () => {
-        this.rootContext.onOpenChange(!this.rootContext.open.value);
-      }
-    }), {
-      default: () => this.$slots.default?.()
-    });
-  }
-});
-
-const comboboxViewportProps = {
-  ...primitive.primitiveProps,
-  /**
-   * Will add `nonce` attribute to the style tag which can be used by Content Security Policy.
-   */
-  nonce: {
-    type: String,
-    required: false
-  }
-};
-const ComboboxViewport = vue.defineComponent({
-  name: "DestylerComboboxViewport",
-  props: comboboxViewportProps,
-  inheritAttrs: false,
-  setup() {
-    const { forwardRef } = composition.useForwardExpose();
-    return {
-      forwardRef
-    };
-  },
-  render() {
-    return [
-      vue.h(primitive.Primitive, vue.mergeProps(this.$attrs, this.$props, {
-        "ref": (el) => this.forwardRef(el),
-        "data-destyler-combobox-viewport": "",
-        "role": "presentation",
-        "style": {
-          position: "relative",
-          flex: 1,
-          overflow: "auto"
-        }
-      }), () => this.$slots.default?.()),
-      vue.h(primitive.Primitive, {
-        as: "style",
-        nonce: this.$props.nonce
-      }, () => `
-      /* Hide scrollbars cross-browser and enable momentum scroll for touch devices */
-      [data-destyler-combobox-viewport] {
-        scrollbar-width:none;
-        -ms-overflow-style: none;
-        -webkit-overflow-scrolling: touch;
-      }
-      [data-destyler-combobox-viewport]::-webkit-scrollbar {
-        display: none;
-      }
-      `)
-    ];
-  }
-});
-
-exports.ComboboxAnchor = ComboboxAnchor;
-exports.ComboboxArrow = ComboboxArrow;
-exports.ComboboxCancel = ComboboxCancel;
-exports.ComboboxContent = ComboboxContent;
-exports.ComboboxContentImpl = ComboboxContentImpl;
-exports.ComboboxEmpty = ComboboxEmpty;
-exports.ComboboxGroup = ComboboxGroup;
-exports.ComboboxInput = ComboboxInput;
-exports.ComboboxItem = ComboboxItem;
-exports.ComboboxItemIndicator = ComboboxItemIndicator;
-exports.ComboboxLabel = ComboboxLabel;
-exports.ComboboxPortal = ComboboxPortal;
-exports.ComboboxRoot = ComboboxRoot;
-exports.ComboboxSeparator = ComboboxSeparator;
-exports.ComboboxTrigger = ComboboxTrigger;
-exports.ComboboxViewport = ComboboxViewport;
-exports.comboboxAnchorProps = comboboxAnchorProps;
-exports.comboboxArrowProps = comboboxArrowProps;
-exports.comboboxCancelProps = comboboxCancelProps;
-exports.comboboxContentEmits = comboboxContentEmits;
-exports.comboboxContentImplEmits = comboboxContentImplEmits;
-exports.comboboxContentImplProps = comboboxContentImplProps;
-exports.comboboxContentProps = comboboxContentProps;
-exports.comboboxEmptyProps = comboboxEmptyProps;
-exports.comboboxGroupProps = comboboxGroupProps;
-exports.comboboxInputProps = comboboxInputProps;
-exports.comboboxItemEmits = comboboxItemEmits;
-exports.comboboxItemIndicatorProps = comboboxItemIndicatorProps;
-exports.comboboxItemProps = comboboxItemProps;
-exports.comboboxLabelProps = comboboxLabelProps;
-exports.comboboxPortalProps = comboboxPortalProps;
-exports.comboboxRootEmits = comboboxRootEmits;
-exports.comboboxRootProps = comboboxRootProps;
-exports.comboboxSeparatorProps = comboboxSeparatorProps;
-exports.comboboxTriggerProps = comboboxTriggerProps;
-exports.comboboxViewportProps = comboboxViewportProps;