@ironsource/shared-ui 1.4.2-test.3 → 1.4.2-test.5

package/src/components/dropdown/DropdownContext.vue.js

@@ -0,0 +1,29 @@
+import { inject } from 'vue';
+
+var Mode = /* @__PURE__ */ ((Mode2) => {
+  Mode2[Mode2["Multi"] = 0] = "Multi";
+  Mode2[Mode2["Single"] = 1] = "Single";
+  return Mode2;
+})(Mode || {});
+var Type = /* @__PURE__ */ ((Type2) => {
+  Type2[Type2["Search"] = 0] = "Search";
+  Type2[Type2["Dropdown"] = 1] = "Dropdown";
+  return Type2;
+})(Type || {});
+const DropdownContext = Symbol(
+  "DropdownContext"
+);
+function useDropdownContext(component) {
+  const context = inject(DropdownContext, null);
+  if (context === null) {
+    const err = new Error(
+      `<${component} /> is missing a parent <Dropdown /> component.`
+    );
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(err, useDropdownContext);
+    throw err;
+  }
+  return context;
+}
+
+export { DropdownContext, Mode, Type, useDropdownContext };

package/src/components/dropdown/Label.vue.js

@@ -0,0 +1,42 @@
+import { defineComponent, openBlock, createElementBlock, unref, normalizeClass, createVNode, withCtx, renderSlot, createBlock, createTextVNode, createCommentVNode } from 'vue';
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import { useDropdownContext } from './DropdownContext.vue.js';
+import { useId } from '../../composables/useId.vue.js';
+/* empty css                                                       */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Label.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "Label",
+  setup(__props) {
+    const id = `is-system-label-${useId().value}`;
+    const api = useDropdownContext("label");
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        id,
+        ref: unref(api).labelRef,
+        class: normalizeClass(["label", { "label--disabled": unref(api).disabled }])
+      }, [
+        createVNode(unref(Text), null, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ]),
+          _: 3
+        }),
+        unref(api).mandatory ? (openBlock(), createBlock(unref(Text), {
+          key: 0,
+          size: "lg",
+          class: "mandatory"
+        }, {
+          default: withCtx(() => [
+            createTextVNode("*")
+          ]),
+          _: 1
+        })) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+var Label = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4bba4499"]]);
+
+export { Label as default };

package/src/components/dropdown/Option.vue.js

@@ -0,0 +1,134 @@
+import { defineComponent, ref, onMounted, onUnmounted, computed, toRaw, openBlock, createElementBlock, normalizeClass, createElementVNode, createBlock, unref, createCommentVNode, renderSlot, createVNode, withCtx, createTextVNode, toDisplayString, withModifiers } from 'vue';
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import { useDropdownContext, Mode } from './DropdownContext.vue.js';
+import { useId } from '../../composables/useId.vue.js';
+import Checkbox from '../checkbox/Checkbox.vue.js';
+import Icon from '../icon/Icon.vue.js';
+import { NOOP } from '@vue/shared';
+/* empty css                                                        */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Option.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = {
+  key: 1,
+  class: "image"
+};
+const _hoisted_2 = {
+  key: 2,
+  class: "start-icon"
+};
+const _hoisted_3 = { class: "text-container" };
+const _hoisted_4 = { key: 0 };
+const _sfc_main = defineComponent({
+  __name: "Option",
+  props: {
+    option: { default: null },
+    subtitle: { default: "" },
+    disabled: { type: Boolean, default: false },
+    selectedProp: { type: Boolean },
+    isIndeterminate: { type: Boolean, default: false },
+    selectAllOption: { type: Boolean, default: false },
+    active: { type: Boolean, default: null }
+  },
+  setup(__props) {
+    const props = __props;
+    const api = useDropdownContext("Option");
+    const id = useId().value;
+    const el = ref(null);
+    const onClick = (event) => {
+      if (!props.selectAllOption) {
+        api.select(props.option);
+      } else {
+        event.stopPropagation();
+      }
+    };
+    onMounted(() => api.registerOption(id, props.disabled, !!props.subtitle));
+    onUnmounted(() => {
+      api.unRegisterOption(id);
+    });
+    const isMulti = computed(() => api.mode === Mode.Multi);
+    const active = computed(() => {
+      if (props.active !== null)
+        return props.active;
+      return api.activeIndex.value !== null ? api.activeOption.value === props.option : false;
+    });
+    const selected = computed(() => {
+      if (props.selectedProp) {
+        return true;
+      }
+      if (api.mode === Mode.Multi && Array.isArray(api.selectedOption.value)) {
+        return toRaw(api.selectedOption.value.includes(props.option));
+      }
+      return toRaw(api.selectedOption.value) === toRaw(props.option);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "el",
+        ref: el,
+        class: normalizeClass(["item-container", {
+          "item-container--disabled": _ctx.disabled,
+          "item-container--active": active.value,
+          "item-container--selected": selected.value,
+          "item-container--multi": isMulti.value
+        }])
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(["item", {
+            "item--multi": isMulti.value,
+            "item--with-icon": _ctx.$slots["icon-start"] || _ctx.$slots.image
+          }])
+        }, [
+          isMulti.value ? (openBlock(), createBlock(unref(Checkbox), {
+            key: 0,
+            id: unref(id).toString(),
+            tabindex: "-1",
+            class: "checkbox",
+            size: "sm",
+            "is-checked": selected.value,
+            "is-indeterminate": _ctx.isIndeterminate && !_ctx.option,
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.disabled ? unref(NOOP)() : onClick($event))
+          }, null, 8, ["id", "is-checked", "is-indeterminate"])) : createCommentVNode("", true),
+          _ctx.$slots.image ? (openBlock(), createElementBlock("div", _hoisted_1, [
+            renderSlot(_ctx.$slots, "image", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          _ctx.$slots["icon-start"] ? (openBlock(), createElementBlock("div", _hoisted_2, [
+            renderSlot(_ctx.$slots, "icon-start", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_3, [
+            createVNode(unref(Text), { size: "sm" }, {
+              default: withCtx(() => [
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
+              ]),
+              _: 3
+            }),
+            _ctx.subtitle ? (openBlock(), createBlock(unref(Text), {
+              key: 0,
+              class: "subtitle",
+              size: "xs"
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(_ctx.subtitle), 1)
+              ]),
+              _: 1
+            })) : createCommentVNode("", true)
+          ])
+        ], 2),
+        unref(api).clearable && selected.value ? (openBlock(), createElementBlock("div", _hoisted_4, [
+          createElementVNode("button", {
+            class: "clear-button",
+            onClick: _cache[1] || (_cache[1] = withModifiers(($event) => unref(api).clearSelection(), ["prevent", "stop"]))
+          }, [
+            createVNode(unref(Icon), {
+              name: "close",
+              width: "8",
+              height: 8
+            })
+          ])
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+var Option = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-0ea361f0"]]);
+
+export { Option as default };

package/src/components/dropdown/SearchInput.vue.js

@@ -0,0 +1,119 @@
+import { defineComponent, useSlots, ref, onMounted, computed, watch, renderSlot, unref, createElementVNode, normalizeClass, openBlock, createElementBlock, createCommentVNode, createVNode, withCtx, createBlock } from 'vue';
+import { useDropdownContext, Mode } from './DropdownContext.vue.js';
+import Icon from '../icon/Icon.vue.js';
+import IconButton from '../button/IconButton.vue.js';
+/* empty css                                                             */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../SearchInput.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = {
+  key: 0,
+  class: "prefix"
+};
+const _hoisted_2 = ["disabled", "placeholder"];
+const _sfc_main = defineComponent({
+  __name: "SearchInput",
+  setup(__props) {
+    const api = useDropdownContext("searchInput");
+    const slots = useSlots();
+    const inputEl = ref(null);
+    const isFocused = ref();
+    onMounted(() => {
+      api.registerInput(inputEl);
+    });
+    const onChange = (event) => {
+      api.toggle(true);
+      api.search(event.target.value);
+    };
+    const showPrefix = computed(() => {
+      return !api.open.value && slots.prefix && !Array.isArray(api.selectedOption.value) && api.selectedOption.value;
+    });
+    const placeholder = computed(() => {
+      if (api.mode === Mode.Multi && Array.isArray(api.selectedOption.value) && api.selectedOption.value.length) {
+        return `${api.selectedOption.value.length} selected`;
+      }
+      if (api.open.value && api.selectedValue.value) {
+        return api.selectedValue.value;
+      }
+      return api.placeholder;
+    });
+    const showClear = computed(() => {
+      return api.query.value !== "" || api.selectedValue.value;
+    });
+    watch(api.open, (value) => {
+      if (value) {
+        inputEl.value.focus();
+      }
+      if (api.mode === Mode.Multi) {
+        return;
+      }
+      if (!value || !inputEl.value) {
+        return;
+      }
+      inputEl.value.value = "";
+    });
+    const rightIcon = computed(() => {
+      return showClear.value ? "cancel" : "search-bold";
+    });
+    const onClearClick = () => {
+      api.clearSelection();
+      inputEl.value.focus();
+    };
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default", {
+        inputRef: inputEl.value,
+        disabled: unref(api).disabled,
+        change: onChange,
+        placeholder: placeholder.value
+      }, () => [
+        createElementVNode("div", {
+          class: normalizeClass(["container", {
+            "container--open": unref(api).open.value,
+            "container--disabled": unref(api).disabled,
+            [`container--${unref(api).size}`]: true,
+            focused: isFocused.value
+          }])
+        }, [
+          showPrefix.value ? (openBlock(), createElementBlock("div", _hoisted_1, [
+            renderSlot(_ctx.$slots, "prefix", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          createElementVNode("input", {
+            ref_key: "inputEl",
+            ref: inputEl,
+            disabled: unref(api).disabled,
+            class: normalizeClass(["input", { "input--disabled": unref(api).disabled }]),
+            placeholder: placeholder.value,
+            onFocusin: _cache[0] || (_cache[0] = ($event) => isFocused.value = true),
+            onFocusout: _cache[1] || (_cache[1] = ($event) => isFocused.value = false),
+            onInput: onChange
+          }, null, 42, _hoisted_2),
+          createVNode(IconButton, {
+            variant: "colorized",
+            size: "sm",
+            theme: "secondary",
+            class: normalizeClass(["search-right-icon", { "search-right-icon-clear": showClear.value }]),
+            disabled: unref(api).disabled
+          }, {
+            default: withCtx(() => [
+              !unref(api).open.value ? (openBlock(), createBlock(unref(Icon), {
+                key: 0,
+                "font-size": "sm",
+                class: "angle-down",
+                name: "angle-down"
+              })) : createCommentVNode("", true),
+              unref(api).open.value ? (openBlock(), createBlock(unref(Icon), {
+                key: 1,
+                "font-size": "sm",
+                name: rightIcon.value,
+                onClick: onClearClick
+              }, null, 8, ["name"])) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["disabled", "class"])
+        ], 2)
+      ], true);
+    };
+  }
+});
+var SearchInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-35368fc5"]]);
+
+export { SearchInput as default };

package/src/components/dropdown/index.vue.js

@@ -0,0 +1,12 @@
+import Dropdown from './Dropdown.vue.js';
+export { default as Dropdown } from './Dropdown.vue.js';
+import Option from './Option.vue.js';
+export { default as Option } from './Option.vue.js';
+import Label from './Label.vue.js';
+export { default as Label } from './Label.vue.js';
+import SearchInput from './SearchInput.vue.js';
+export { default as SearchInput } from './SearchInput.vue.js';
+
+const DropdownTypes = () => [Dropdown, Option, Label, SearchInput];
+
+export { DropdownTypes };

package/src/components/emptyState/EmptyState.vue.js

@@ -0,0 +1,100 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, createElementVNode, renderSlot, createBlock, normalizeProps, mergeProps, createCommentVNode, unref, withCtx, createTextVNode, toDisplayString } from 'vue';
+import Button from '../button/Button.vue.js';
+import '../button/IconButton.vue.js';
+import '../button/ScrollButton.vue.js';
+import EmptyStateIcon from './EmptyStateIcon.vue.js';
+import Icon from '../icon/Icon.vue.js';
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+/* empty css                                                            */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../EmptyState.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = { class: "empty-state-title-container" };
+const _sfc_main = defineComponent({
+  __name: "EmptyState",
+  props: {
+    title: { default: void 0 },
+    subtitle: { default: void 0 },
+    buttonText: { default: void 0 },
+    isHorizontal: { type: Boolean, default: false },
+    hasIcon: { type: Boolean, default: true },
+    isBordered: { type: Boolean, default: false },
+    iconName: { default: null },
+    fontSize: { default: "5rem" },
+    size: { default: "lg" },
+    iconWidth: { default: 44 },
+    iconHeight: { default: 44 }
+  },
+  emits: ["click"],
+  setup(__props) {
+    const props = __props;
+    const iconProps = computed(() => {
+      return {
+        width: props.iconWidth,
+        height: props.iconHeight
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["empty-state-container", { horizontal: _ctx.isHorizontal, bordered: _ctx.isBordered }])
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(`empty-state-icon-container empty-state-icon-container--${_ctx.size}`)
+        }, [
+          _ctx.hasIcon ? renderSlot(_ctx.$slots, "icon", { key: 0 }, () => [
+            !_ctx.iconName ? (openBlock(), createBlock(EmptyStateIcon, normalizeProps(mergeProps({ key: 0 }, iconProps.value)), null, 16)) : createCommentVNode("", true),
+            _ctx.iconName ? (openBlock(), createBlock(unref(Icon), {
+              key: 1,
+              name: _ctx.iconName,
+              "font-size": _ctx.fontSize,
+              class: "empty-state-icon"
+            }, null, 8, ["name", "font-size"])) : createCommentVNode("", true)
+          ], true) : createCommentVNode("", true)
+        ], 2),
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            _ctx.title ? (openBlock(), createBlock(unref(Text), {
+              key: 0,
+              size: "lg",
+              strong: "",
+              class: "empty-state-title"
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(_ctx.title), 1)
+              ]),
+              _: 1
+            })) : createCommentVNode("", true)
+          ], true),
+          renderSlot(_ctx.$slots, "subtitle", {}, () => [
+            _ctx.subtitle ? (openBlock(), createBlock(unref(Text), {
+              key: 0,
+              size: "sm",
+              class: "empty-state-subtitle"
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(_ctx.subtitle), 1)
+              ]),
+              _: 1
+            })) : createCommentVNode("", true)
+          ], true)
+        ]),
+        renderSlot(_ctx.$slots, "button", {}, () => [
+          _ctx.buttonText ? (openBlock(), createBlock(unref(Button), {
+            key: 0,
+            theme: "secondary",
+            class: "empty-state-button",
+            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click"))
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.buttonText), 1)
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ], true)
+      ], 2);
+    };
+  }
+});
+var EmptyState = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-54b6f08e"]]);
+
+export { EmptyState as default };

package/src/components/emptyState/EmptyStateIcon.vue.js

@@ -0,0 +1,44 @@
+import { openBlock, createElementBlock, pushScopeId, popScopeId, createElementVNode } from 'vue';
+/* empty css                                                                */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../EmptyStateIcon.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {};
+
+const _withScopeId = n => (pushScopeId("data-v-0d4e4f1b"),n=n(),popScopeId(),n);
+const _hoisted_1 = {
+  viewBox: "0 0 51 51",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+};
+const _hoisted_2 = /*#__PURE__*/ _withScopeId(() => /*#__PURE__*/createElementVNode("rect", {
+  x: "20.4343",
+  y: "25.813",
+  width: "8.76522",
+  height: "23.6766",
+  rx: "4.38261",
+  transform: "rotate(44.7222 20.4343 25.813)",
+  fill: "currentColor"
+}, null, -1));
+const _hoisted_3 = /*#__PURE__*/ _withScopeId(() => /*#__PURE__*/createElementVNode("ellipse", {
+  rx: "18.1565",
+  ry: "18.1565",
+  transform: "matrix(-1 0 0 1 28.8174 22.6824)",
+  fill: "currentColor"
+}, null, -1));
+const _hoisted_4 = /*#__PURE__*/ _withScopeId(() => /*#__PURE__*/createElementVNode("circle", {
+  r: "13.7739",
+  transform: "matrix(-1 0 0 1 28.8173 22.6826)",
+  fill: "#DDDFE1"
+}, null, -1));
+const _hoisted_5 = [
+  _hoisted_2,
+  _hoisted_3,
+  _hoisted_4
+];
+
+function _sfc_render(_ctx, _cache) {
+  return (openBlock(), createElementBlock("svg", _hoisted_1, _hoisted_5))
+}
+var EmptyStateIcon = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render],['__scopeId',"data-v-0d4e4f1b"]]);
+
+export { EmptyStateIcon as default };

package/src/components/emptyState/index.vue.js

@@ -0,0 +1,6 @@
+import EmptyState from './EmptyState.vue.js';
+export { default as EmptyState } from './EmptyState.vue.js';
+
+const EmptyStateTypes = () => [EmptyState];
+
+export { EmptyStateTypes };

package/src/components/filterDropdown/AddFilterButton.vue.js

@@ -0,0 +1,53 @@
+import { defineComponent, openBlock, createBlock, normalizeClass, createSlots, withCtx, createVNode, renderSlot } from 'vue';
+import Icon from '../icon/Icon.vue.js';
+import Chip from '../chip/Chip.vue.js';
+import Text from '../typography/Text.vue.js';
+/* empty css                                                                 */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../AddFilterButton.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "AddFilterButton",
+  props: {
+    selected: { type: Boolean },
+    disabled: { type: Boolean },
+    prefix: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Chip, {
+        clearable: "",
+        class: normalizeClass(["add-filter", { disabled: _ctx.disabled }]),
+        selected: _ctx.selected,
+        disabled: _ctx.disabled,
+        prefix: _ctx.prefix
+      }, createSlots({
+        default: withCtx(() => [
+          createVNode(Text, {
+            size: "sm",
+            strong: ""
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default", {}, void 0, true)
+            ]),
+            _: 3
+          })
+        ]),
+        _: 2
+      }, [
+        !_ctx.prefix ? {
+          name: "icon-start",
+          fn: withCtx(() => [
+            createVNode(Icon, {
+              name: "tune",
+              "font-size": "sm"
+            })
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1032, ["class", "selected", "disabled", "prefix"]);
+    };
+  }
+});
+var AddFilterButton = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-aef29636"]]);
+
+export { AddFilterButton as default };

package/src/components/filterDropdown/FilterDropdown.vue.js

@@ -0,0 +1,58 @@
+import { defineComponent, openBlock, createBlock, unref, withCtx, createVNode, createTextVNode, toDisplayString } from 'vue';
+import Dropdown from '../dropdown/Dropdown.vue.js';
+import Option from '../dropdown/Option.vue.js';
+import '../dropdown/Label.vue.js';
+import '../dropdown/SearchInput.vue.js';
+import AddFilterButton from './AddFilterButton.vue.js';
+/* empty css                                                                */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../FilterDropdown.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "FilterDropdown",
+  props: {
+    displayValue: {},
+    text: { default: "Add Filter" },
+    disabled: { type: Boolean, default: false },
+    onSearch: {},
+    options: {},
+    addNewFilter: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Dropdown), {
+        "display-value": _ctx.displayValue,
+        disabled: _ctx.disabled,
+        "on-search": _ctx.onSearch,
+        distance: 0,
+        skidding: 0,
+        "is-on-top": "",
+        options: _ctx.options,
+        "onUpdate:selected": _ctx.addNewFilter
+      }, {
+        input: withCtx(() => [
+          createVNode(AddFilterButton, {
+            class: "add-filter-button",
+            disabled: _ctx.disabled
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.text), 1)
+            ]),
+            _: 1
+          }, 8, ["disabled"])
+        ]),
+        default: withCtx(({ option }) => [
+          createVNode(unref(Option), { option }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(option), 1)
+            ]),
+            _: 2
+          }, 1032, ["option"])
+        ]),
+        _: 1
+      }, 8, ["display-value", "disabled", "on-search", "options", "onUpdate:selected"]);
+    };
+  }
+});
+var FilterDropdown = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-5caeb269"]]);
+
+export { FilterDropdown as default };

package/src/components/filterDropdown/index.vue.js

@@ -0,0 +1,8 @@
+import FilterDropdown from './FilterDropdown.vue.js';
+export { default as FilterDropdown } from './FilterDropdown.vue.js';
+import AddFilterButton from './AddFilterButton.vue.js';
+export { default as AddFilterButton } from './AddFilterButton.vue.js';
+
+const FilterDropdownTypes = () => [FilterDropdown, AddFilterButton];
+
+export { FilterDropdownTypes };

package/src/components/filtersPanel/FilterSearchInput.vue.js

@@ -0,0 +1,54 @@
+import { defineComponent, ref, onMounted, openBlock, createElementBlock, createVNode, unref, withCtx, createElementVNode } from 'vue';
+import '../dropdown/Dropdown.vue.js';
+import '../dropdown/Option.vue.js';
+import '../dropdown/Label.vue.js';
+import SearchInput from '../dropdown/SearchInput.vue.js';
+import Icon from '../icon/Icon.vue.js';
+/* empty css                                                                   */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../FilterSearchInput.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = {
+  class: "search-container",
+  tabindex: "0"
+};
+const _hoisted_2 = { class: "search" };
+const _hoisted_3 = ["placeholder", "disabled", "onInput"];
+const _sfc_main = defineComponent({
+  __name: "FilterSearchInput",
+  setup(__props) {
+    const element = ref(null);
+    onMounted(() => {
+      setTimeout(() => {
+        element.value.focus();
+      }, 250);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(unref(SearchInput), null, {
+          default: withCtx(({ disabled, change, placeholder }) => [
+            createElementVNode("div", _hoisted_2, [
+              createVNode(unref(Icon), {
+                class: "search-icon",
+                width: "12",
+                height: "12",
+                name: "search"
+              }),
+              createElementVNode("input", {
+                ref_key: "element",
+                ref: element,
+                class: "search-input",
+                placeholder: placeholder ? placeholder : "Search",
+                disabled,
+                onInput: change
+              }, null, 40, _hoisted_3)
+            ])
+          ]),
+          _: 1
+        })
+      ]);
+    };
+  }
+});
+var FilterSearchInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e9685340"]]);
+
+export { FilterSearchInput as default };