@ironsource/shared-ui 2.0.0-rc.3 → 2.0.0-test.2

package/components/autocompleteDropdown/AutocompleteDropdown.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     options: unknown[];
     selected?: unknown[];
     placeholder: string;
@@ -42,6 +42,14 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     displayValue: (option: unknown) => string;
     handleSearch: (option: any, term: string) => boolean;
     grouped: boolean;
+}>, {
+    "input-option"?(_: {
+        option: unknown;
+    }): any;
+    default?(_: {
+        option: any;
+        active: boolean;
+    }): any;
 }>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
@@ -54,7 +62,15 @@ type __VLS_TypePropsToRuntimeProps<T> = {
     };
 };
 type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? P[K] & {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
-    } : P[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };

package/components/autocompleteDropdown/AutocompleteDropdown.vue.js

@@ -1,150 +1,7 @@
-import { defineComponent, ref, computed, watch, nextTick, openBlock, createBlock, unref, mergeProps, withModifiers, withCtx, createVNode, renderSlot, createTextVNode, toDisplayString } from 'vue';
-import Dropdown from '../dropdown/v3/Dropdown.vue.js';
-/* empty css                                                                     */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-/* empty css                                                                  *//* empty css                                                               *//* empty css                                                                    */import '@vue/shared';
-/* empty css                                                                         *//* empty css                                                                        *//* empty css                                                                   *//* empty css                                                                           *//* empty css                                                                       *//* empty css                                                                               */import 'floating-vue';
-/* empty css                                                      *//* empty css                                                                         *//* empty css                                                                              */import GroupOption from './GroupOption.vue.js';
-import AutocompleteInput from './AutocompleteInput.vue.js';
-import { DEFAULT_PLACEHOLDER, GROUP_OPTION_FLAG } from './consts.vue.js';
-import { useKeyboardNavigation } from './useKeyboardNavigation.vue.js';
-/* empty css                                                                      */
-import "../../AutocompleteDropdown.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "AutocompleteDropdown",
-  props: {
-    options: { default: () => [] },
-    selected: { default: () => [] },
-    placeholder: { default: DEFAULT_PLACEHOLDER },
-    displayValue: { type: Function, default: (option) => option.toString() },
-    handleSearch: { type: Function, default: () => true },
-    grouped: { type: Boolean, default: false },
-    testId: { default: "" }
-  },
-  emits: ["update:selected"],
-  setup(__props, { emit }) {
-    const props = __props;
-    const inputRef = ref(null);
-    const dropdownRef = ref(null);
-    const selection = computed({
-      get() {
-        return props.selected;
-      },
-      set(value) {
-        emit("update:selected", value);
-      }
-    });
-    function selectOption(option) {
-      selection.value.push(option);
-      inputRef.value.focusInput();
-    }
-    function deselectOption(option) {
-      selection.value.splice(selection.value.indexOf(option), 1);
-    }
-    async function scrollToTop() {
-      await nextTick();
-      setTimeout(() => {
-        dropdownRef?.value?.scrollTo(0);
-      });
-    }
-    const searchQuery = ref("");
-    const isGroup = (option) => option && !!option[GROUP_OPTION_FLAG];
-    const flatOptions = computed(() => {
-      if (!props.grouped)
-        return props.options;
-      return props.options.reduce((prev, group) => {
-        const { options = [], ...otherFields } = group;
-        const groupOption = {
-          ...otherFields,
-          [GROUP_OPTION_FLAG]: true
-        };
-        return [...prev, groupOption, ...options];
-      }, []);
-    });
-    const filteredOptions = computed(() => {
-      const options = flatOptions.value.filter((option) => !selection.value.includes(option)).filter((option) => {
-        if (isGroup(option))
-          return true;
-        return props.handleSearch(option, searchQuery.value);
-      });
-      if (props.grouped) {
-        return options.filter((option, index) => {
-          const nextOption = options[index + 1];
-          return isGroup(option) ? nextOption && !isGroup(nextOption) : true;
-        });
-      }
-      return options;
-    });
-    const { isFocused, keyDownHandler } = useKeyboardNavigation({
-      options: filteredOptions,
-      canFocus: (option) => !isGroup(option),
-      scrollTo: (index) => dropdownRef?.value?.scrollTo(index),
-      selectItem: (option) => {
-        dropdownRef?.value?.selectItem(option);
-        scrollToTop();
-      }
-    });
-    const distance = ref(0);
-    watch(props.selected, async () => {
-      distance.value += 1;
-      await nextTick();
-      distance.value = 0;
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(Dropdown), mergeProps({
-        ref_key: "dropdownRef",
-        ref: dropdownRef,
-        class: "autocomplete-dropdown"
-      }, _ctx.$attrs, {
-        selected: unref(selection),
-        options: unref(filteredOptions),
-        "on-search": () => true,
-        "display-value": __props.displayValue,
-        "keep-open": "",
-        "is-on-top": false,
-        multi: false,
-        "show-select-all": false,
-        "auto-size": "",
-        distance: distance.value,
-        "disable-keyboard-events": "",
-        "test-id": __props.testId,
-        onOpened: scrollToTop,
-        onKeydown: withModifiers(unref(keyDownHandler), ["stop"]),
-        "onUpdate:selected": selectOption
-      }), {
-        input: withCtx(() => [
-          createVNode(AutocompleteInput, {
-            ref_key: "inputRef",
-            ref: inputRef,
-            value: unref(selection),
-            placeholder: __props.placeholder,
-            "display-value": __props.displayValue,
-            "test-id": __props.testId,
-            onRemove: deselectOption,
-            onSearch: _cache[0] || (_cache[0] = ($event) => searchQuery.value = $event)
-          }, {
-            option: withCtx(({ option }) => [
-              renderSlot(_ctx.$slots, "input-option", { option }, void 0, true)
-            ]),
-            _: 3
-          }, 8, ["value", "placeholder", "display-value", "test-id"])
-        ]),
-        default: withCtx(({ option }) => [
-          __props.grouped && isGroup(option) ? (openBlock(), createBlock(GroupOption, { key: 0 }, {
-            default: withCtx(() => [
-              createTextVNode(toDisplayString(__props.displayValue(option)), 1)
-            ]),
-            _: 2
-          }, 1024)) : renderSlot(_ctx.$slots, "default", {
-            key: 1,
-            option,
-            active: unref(isFocused)(option)
-          }, void 0, true)
-        ]),
-        _: 3
-      }, 16, ["selected", "options", "on-search", "display-value", "distance", "test-id", "onKeydown"]);
-    };
-  }
-});
-var AutocompleteDropdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-74e20077"]]);
-
-export { AutocompleteDropdown as default };
+import o from "./AutocompleteDropdown.vue2.js";
+/* empty css                           */import e from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../AutocompleteDropdown.vue_vue_type_style_index_0_scoped_214ddaf4_lang.css"; //*');
+const d = /* @__PURE__ */ e(o, [["__scopeId", "data-v-214ddaf4"]]);
+export {
+  d as default
+};

package/components/autocompleteDropdown/AutocompleteDropdown.vue2.js

@@ -0,0 +1,120 @@
+ import "../../AutocompleteDropdown.vue_vue_type_style_index_0_scoped_214ddaf4_lang.css"; import { defineComponent as x, ref as d, computed as f, watch as G, nextTick as w, openBlock as O, createBlock as g, unref as a, mergeProps as L, withModifiers as N, withCtx as c, createVNode as P, renderSlot as k, createTextVNode as b, toDisplayString as B } from "vue";
+import C from "../dropdown/v3/Dropdown.vue.js";
+import "../dropdown/common/Option.vue.js";
+import "../dropdown/common/Label.vue.js";
+import "../dropdown/common/SearchInput.vue.js";
+import E from "./GroupOption.vue.js";
+import K from "./AutocompleteInput.vue.js";
+import { DEFAULT_PLACEHOLDER as U, GROUP_OPTION_FLAG as T } from "./consts.js";
+import { useKeyboardNavigation as $ } from "./useKeyboardNavigation.js";
+const Y = /* @__PURE__ */ x({
+  __name: "AutocompleteDropdown",
+  props: {
+    options: { default: () => [] },
+    selected: { default: () => [] },
+    placeholder: { default: U },
+    displayValue: { type: Function, default: (l) => l.toString() },
+    handleSearch: { type: Function, default: () => !0 },
+    grouped: { type: Boolean, default: !1 },
+    testId: { default: "" }
+  },
+  emits: ["update:selected"],
+  setup(l, { emit: I }) {
+    const n = l, m = d(null), u = d(null), s = f({
+      get() {
+        return n.selected;
+      },
+      set(e) {
+        I("update:selected", e);
+      }
+    });
+    function F(e) {
+      s.value.push(e), m.value.focusInput();
+    }
+    function R(e) {
+      s.value.splice(s.value.indexOf(e), 1);
+    }
+    async function v() {
+      await w(), setTimeout(() => {
+        u?.value?.scrollTo(0);
+      });
+    }
+    const y = d(""), r = (e) => e && !!e[T], D = f(() => n.grouped ? n.options.reduce((e, o) => {
+      const { options: t = [], ...i } = o, A = {
+        ...i,
+        [T]: !0
+      };
+      return [...e, A, ...t];
+    }, []) : n.options), h = f(() => {
+      const e = D.value.filter((o) => !s.value.includes(o)).filter((o) => r(o) ? !0 : n.handleSearch(o, y.value));
+      return n.grouped ? e.filter((o, t) => {
+        const i = e[t + 1];
+        return r(o) ? i && !r(i) : !0;
+      }) : e;
+    }), { isFocused: S, keyDownHandler: V } = $({
+      options: h,
+      canFocus: (e) => !r(e),
+      scrollTo: (e) => u?.value?.scrollTo(e),
+      selectItem: (e) => {
+        u?.value?.selectItem(e), v();
+      }
+    }), p = d(0);
+    return G(n.selected, async () => {
+      p.value += 1, await w(), p.value = 0;
+    }), (e, o) => (O(), g(a(C), L({
+      ref_key: "dropdownRef",
+      ref: u,
+      class: "autocomplete-dropdown"
+    }, e.$attrs, {
+      selected: a(s),
+      options: a(h),
+      "on-search": () => !0,
+      "display-value": l.displayValue,
+      "keep-open": "",
+      "is-on-top": !1,
+      multi: !1,
+      "show-select-all": !1,
+      "auto-size": "",
+      distance: p.value,
+      "disable-keyboard-events": "",
+      "test-id": l.testId,
+      onOpened: v,
+      onKeydown: N(a(V), ["stop"]),
+      "onUpdate:selected": F
+    }), {
+      input: c(() => [
+        P(K, {
+          ref_key: "inputRef",
+          ref: m,
+          value: a(s),
+          placeholder: l.placeholder,
+          "display-value": l.displayValue,
+          "test-id": l.testId,
+          onRemove: R,
+          onSearch: o[0] || (o[0] = (t) => y.value = t)
+        }, {
+          option: c(({ option: t }) => [
+            k(e.$slots, "input-option", { option: t }, void 0, !0)
+          ]),
+          _: 3
+        }, 8, ["value", "placeholder", "display-value", "test-id"])
+      ]),
+      default: c(({ option: t }) => [
+        l.grouped && r(t) ? (O(), g(E, { key: 0 }, {
+          default: c(() => [
+            b(B(l.displayValue(t)), 1)
+          ]),
+          _: 2
+        }, 1024)) : k(e.$slots, "default", {
+          key: 1,
+          option: t,
+          active: a(S)(t)
+        }, void 0, !0)
+      ]),
+      _: 3
+    }, 16, ["selected", "options", "on-search", "display-value", "distance", "test-id", "onKeydown"]));
+  }
+});
+export {
+  Y as default
+};

package/components/autocompleteDropdown/AutocompleteInput.vue.d.ts

@@ -1,4 +1,5 @@
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+declare function focusInput(): void;
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     value: unknown[];
     displayValue?: (option: unknown) => string;
     placeholder?: string;
@@ -9,10 +10,9 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     placeholder: string;
     testId: string;
 }>, {
-    focusInput: () => void;
+    focusInput: typeof focusInput;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     remove: (option: unknown) => void;
-} & {
     search: (searchQuery: string) => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     value: unknown[];
@@ -32,6 +32,10 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     testId: string;
     placeholder: string;
     displayValue: (option: unknown) => string;
+}>, {
+    option?(_: {
+        option: unknown;
+    }): any;
 }>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
@@ -44,7 +48,15 @@ type __VLS_TypePropsToRuntimeProps<T> = {
     };
 };
 type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? P[K] & {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
-    } : P[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };

package/components/autocompleteDropdown/AutocompleteInput.vue.js

@@ -1,99 +1,7 @@
-import { defineComponent, ref, computed, watch, openBlock, createElementBlock, normalizeClass, unref, withModifiers, Fragment, renderList, renderSlot, createVNode, withCtx, createTextVNode, toDisplayString, createElementVNode } from 'vue';
-import Icon from '../icon/v3/Icon.vue.js';
-import Text from '../typography/Text.vue.js';
-import { useDropdownContext } from '../dropdown/common/DropdownContext.vue.js';
-import { DEFAULT_PLACEHOLDER } from './consts.vue.js';
-import { AutocompleteInputTestIdModifiers } from '../../testids/index.vue.js';
-/* empty css                                                                   */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-
-import "../../AutocompleteInput.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = ["data-testid", "onClick"];
-const _hoisted_2 = ["data-testid"];
-const _hoisted_3 = ["value", "placeholder", "data-testid"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "AutocompleteInput",
-  props: {
-    value: { default: () => [] },
-    displayValue: { type: Function, default: (option) => option.toString() },
-    placeholder: { default: DEFAULT_PLACEHOLDER },
-    testId: { default: "" }
-  },
-  emits: ["remove", "search"],
-  setup(__props, { expose, emit }) {
-    const props = __props;
-    const api = useDropdownContext("autocompleteInput");
-    const inputEl = ref(null);
-    const isOpen = computed(() => api.open.value);
-    const getOptionLabel = (option) => props.displayValue(option);
-    function onContainerClick() {
-      api.toggle(true);
-      focusInput();
-    }
-    const onSearch = (event) => {
-      const { value } = event.target;
-      api.toggle(true);
-      api.search(value);
-    };
-    function removeOption(option) {
-      emit("remove", option);
-      if (isOpen.value) {
-        focusInput();
-      }
-    }
-    watch(api.query, (value) => {
-      emit("search", value);
-    });
-    function focusInput() {
-      inputEl.value?.focus();
-    }
-    expose({
-      focusInput
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass(["autocomplete-input", { "autocomplete-input--focused": unref(isOpen) }]),
-        "data-testid": `${__props.testId}-${unref(AutocompleteInputTestIdModifiers).WRAPPER}`,
-        onClick: withModifiers(onContainerClick, ["stop"])
-      }, [
-        (openBlock(true), createElementBlock(Fragment, null, renderList(__props.value, (option, index) => {
-          return openBlock(), createElementBlock("div", {
-            key: index,
-            "data-testid": `${__props.testId}-${unref(AutocompleteInputTestIdModifiers).SELECTED_OPTION}-${index}`,
-            class: "autocomplete-input__option"
-          }, [
-            renderSlot(_ctx.$slots, "option", { option }, () => [
-              createVNode(Text, {
-                size: "sm",
-                "is-truncated": ""
-              }, {
-                default: withCtx(() => [
-                  createTextVNode(toDisplayString(getOptionLabel(option)), 1)
-                ]),
-                _: 2
-              }, 1024)
-            ], true),
-            createVNode(unref(Icon), {
-              class: "autocomplete-input__close-icon",
-              name: "close-bold",
-              "font-size": "sm",
-              onClick: withModifiers(($event) => removeOption(option), ["stop"])
-            }, null, 8, ["onClick"])
-          ], 8, _hoisted_2);
-        }), 128)),
-        createElementVNode("input", {
-          ref_key: "inputEl",
-          ref: inputEl,
-          class: "autocomplete-input__search-field",
-          type: "text",
-          value: unref(api).query.value,
-          placeholder: __props.placeholder,
-          "data-testid": `${__props.testId}-${unref(AutocompleteInputTestIdModifiers).SEARCH_FIELD}`,
-          onInput: onSearch
-        }, null, 40, _hoisted_3)
-      ], 10, _hoisted_1);
-    };
-  }
-});
-var AutocompleteInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-169f694c"]]);
-
-export { AutocompleteInput as default };
+import o from "./AutocompleteInput.vue2.js";
+/* empty css                        */import t from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../AutocompleteInput.vue_vue_type_style_index_0_scoped_3c232515_lang.css"; //*');
+const c = /* @__PURE__ */ t(o, [["__scopeId", "data-v-3c232515"]]);
+export {
+  c as default
+};

package/components/autocompleteDropdown/AutocompleteInput.vue2.js

@@ -0,0 +1,79 @@
+ import "../../AutocompleteInput.vue_vue_type_style_index_0_scoped_3c232515_lang.css"; import { defineComponent as k, ref as y, computed as $, watch as L, openBlock as u, createElementBlock as s, normalizeClass as A, unref as n, withModifiers as f, Fragment as D, renderList as O, renderSlot as S, createVNode as h, withCtx as T, createTextVNode as x, toDisplayString as V, createElementVNode as w } from "vue";
+import F from "../icon/Icon.vue.js";
+import N from "../typography/Text.vue.js";
+import { useDropdownContext as P } from "../dropdown/common/DropdownContext.js";
+import { DEFAULT_PLACEHOLDER as R } from "./consts.js";
+import { AutocompleteInputTestIdModifiers as c } from "../../testids/index.js";
+const z = ["data-testid", "onClick"], b = ["data-testid"], q = ["value", "placeholder", "data-testid"], J = /* @__PURE__ */ k({
+  __name: "AutocompleteInput",
+  props: {
+    value: { default: () => [] },
+    displayValue: { type: Function, default: (t) => t.toString() },
+    placeholder: { default: R },
+    testId: { default: "" }
+  },
+  emits: ["remove", "search"],
+  setup(t, { expose: v, emit: i }) {
+    const C = t, o = P("autocompleteInput"), r = y(null), d = $(() => o.open.value), E = (e) => C.displayValue(e);
+    function I() {
+      o.toggle(!0), l();
+    }
+    const _ = (e) => {
+      const { value: p } = e.target;
+      o.toggle(!0), o.search(p);
+    };
+    function g(e) {
+      i("remove", e), d.value && l();
+    }
+    L(o.query, (e) => {
+      i("search", e);
+    });
+    function l() {
+      r.value?.focus();
+    }
+    return v({
+      focusInput: l
+    }), (e, p) => (u(), s("div", {
+      class: A(["autocomplete-input", { "autocomplete-input--focused": n(d) }]),
+      "data-testid": `${t.testId}-${n(c).WRAPPER}`,
+      onClick: f(I, ["stop"])
+    }, [
+      (u(!0), s(D, null, O(t.value, (a, m) => (u(), s("div", {
+        key: m,
+        "data-testid": `${t.testId}-${n(c).SELECTED_OPTION}-${m}`,
+        class: "autocomplete-input__option"
+      }, [
+        S(e.$slots, "option", { option: a }, () => [
+          h(N, {
+            size: "sm",
+            "is-truncated": ""
+          }, {
+            default: T(() => [
+              x(V(E(a)), 1)
+            ]),
+            _: 2
+          }, 1024)
+        ], !0),
+        h(n(F), {
+          class: "autocomplete-input__close-icon",
+          name: "close-bold",
+          "font-size": "sm",
+          onClick: f((B) => g(a), ["stop"])
+        }, null, 8, ["onClick"])
+      ], 8, b))), 128)),
+      w("input", {
+        ref_key: "inputEl",
+        ref: r,
+        class: "autocomplete-input__search-field",
+        type: "text",
+        value: n(o).query.value,
+        placeholder: t.placeholder,
+        "data-testid": `${t.testId}-${n(c).SEARCH_FIELD}`,
+        onInput: _
+      }, null, 40, q)
+    ], 10, z));
+  }
+});
+export {
+  J as default
+};

package/components/autocompleteDropdown/GroupOption.vue.d.ts

@@ -1,2 +1,9 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>, {
+    default?(_: {}): any;
+}>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/autocompleteDropdown/GroupOption.vue.js

@@ -1,42 +1,7 @@
-import { defineComponent, ref, onMounted, onUnmounted, openBlock, createElementBlock, withModifiers, unref, createVNode, withCtx, renderSlot } from 'vue';
-import { NOOP } from '@vue/shared';
-/* empty css                                                                     */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-import Text from '../typography/Text.vue.js';
-import { useDropdownContext } from '../dropdown/common/DropdownContext.vue.js';
-import { useId } from '../../composables/useId.vue.js';
-/* empty css                                                             */
-import "../../GroupOption.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "GroupOption",
-  setup(__props) {
-    const api = useDropdownContext("GroupOption");
-    const id = useId().value;
-    const el = ref(null);
-    onMounted(() => api.registerOption(id, true, false));
-    onUnmounted(() => api.unRegisterOption(id));
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        ref_key: "el",
-        ref: el,
-        class: "group-option",
-        onClick: _cache[0] || (_cache[0] = withModifiers(
-          (...args) => unref(NOOP) && unref(NOOP)(...args),
-          ["stop"]
-        ))
-      }, [
-        createVNode(unref(Text), {
-          size: "md",
-          strong: ""
-        }, {
-          default: withCtx(() => [
-            renderSlot(_ctx.$slots, "default", {}, void 0, true)
-          ]),
-          _: 3
-        })
-      ], 512);
-    };
-  }
-});
-var GroupOption = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-52c8859b"]]);
-
-export { GroupOption as default };
+import o from "./GroupOption.vue2.js";
+/* empty css                  */import e from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../GroupOption.vue_vue_type_style_index_0_scoped_8aae9eb9_lang.css"; //*');
+const s = /* @__PURE__ */ e(o, [["__scopeId", "data-v-8aae9eb9"]]);
+export {
+  s as default
+};

package/components/autocompleteDropdown/GroupOption.vue2.js

@@ -0,0 +1,35 @@
+ import "../../GroupOption.vue_vue_type_style_index_0_scoped_8aae9eb9_lang.css"; import { defineComponent as u, ref as m, onMounted as f, onUnmounted as l, openBlock as d, createElementBlock as a, withModifiers as c, unref as o, createVNode as _, withCtx as O, renderSlot as g } from "vue";
+import { NOOP as n } from "@vue/shared";
+import "../typography/Heading.vue.js";
+import k from "../typography/Text.vue.js";
+import { useDropdownContext as x } from "../dropdown/common/DropdownContext.js";
+import { useId as C } from "../../composables/useId.js";
+const y = /* @__PURE__ */ u({
+  __name: "GroupOption",
+  setup(v) {
+    const e = x("GroupOption"), t = C().value, i = m(null);
+    return f(() => e.registerOption(t, !0, !1)), l(() => e.unRegisterOption(t)), (p, r) => (d(), a("div", {
+      ref_key: "el",
+      ref: i,
+      class: "group-option",
+      onClick: r[0] || (r[0] = c(
+        //@ts-ignore
+        (...s) => o(n) && o(n)(...s),
+        ["stop"]
+      ))
+    }, [
+      _(o(k), {
+        size: "md",
+        strong: ""
+      }, {
+        default: O(() => [
+          g(p.$slots, "default", {}, void 0, !0)
+        ]),
+        _: 3
+      })
+    ], 512));
+  }
+});
+export {
+  y as default
+};

package/components/autocompleteDropdown/consts.js

@@ -0,0 +1,5 @@
+const _ = "Add item...", O = "__IS_GROUP";
+export {
+  _ as DEFAULT_PLACEHOLDER,
+  O as GROUP_OPTION_FLAG
+};