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

package/src/components/includeExclude/IncludeExcludeOptionDraggable.vue.js

@@ -0,0 +1,123 @@
+import { defineComponent, ref, computed, openBlock, createElementBlock, unref, normalizeClass, createElementVNode, renderSlot, createCommentVNode, createVNode, withCtx, createTextVNode, toDisplayString, createBlock, withModifiers } from 'vue';
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import { useIncludeExcludeContext } from './IncludeExcludeContext.vue.js';
+import { useId } from '../../composables/useId.vue.js';
+import _sfc_main$1 from '../tooltip/Tooltip.vue.js';
+import Icon from '../icon/Icon.vue.js';
+/* empty css                                                                               */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../IncludeExcludeOptionDraggable.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = ["id"];
+const _hoisted_2 = {
+  key: 0,
+  class: "image"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "start-icon"
+};
+const _hoisted_4 = { class: "text-container" };
+const _hoisted_5 = { key: 0 };
+const isMulti = true;
+const tooltipDelay = 200;
+const _sfc_main = defineComponent({
+  __name: "IncludeExcludeOptionDraggable",
+  props: {
+    option: {},
+    subtitle: { default: "" },
+    disabled: { type: Boolean, default: false },
+    clearable: { type: Boolean, default: false },
+    titleText: { default: "" }
+  },
+  setup(__props) {
+    const props = __props;
+    const api = useIncludeExcludeContext("IncludeExcludeOption");
+    const id = useId().value;
+    const el = ref(null);
+    const active = computed(() => {
+      return api.activeIndex.value !== null ? api.activeOption.value === props.option : false;
+    });
+    const selected = computed(() => {
+      return api.selectedOption.value.includes(props.option);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        id: unref(id).toString(),
+        ref_key: "el",
+        ref: el,
+        class: normalizeClass(["item-container-draggable", {
+          "item-container-draggable--disabled": _ctx.disabled,
+          "item-container-draggable--active": active.value,
+          "item-container-draggable--selected": selected.value,
+          "item-container-draggable--multi": isMulti,
+          "item-container-draggable--two-lines": _ctx.subtitle?.length
+        }])
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(["item", {
+            "item--multi": isMulti,
+            "item--with-icon": _ctx.$slots["icon-start"] || _ctx.$slots.image,
+            "item--without-icon": !_ctx.$slots["icon-start"] && !_ctx.$slots.image
+          }])
+        }, [
+          _ctx.$slots.image ? (openBlock(), createElementBlock("div", _hoisted_2, [
+            renderSlot(_ctx.$slots, "image", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          _ctx.$slots["icon-start"] ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            renderSlot(_ctx.$slots, "icon-start", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_4, [
+            createVNode(unref(_sfc_main$1), {
+              delay: tooltipDelay,
+              text: _ctx.titleText
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(Text), {
+                  size: "sm",
+                  "is-truncated": ""
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(_ctx.titleText), 1)
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            }, 8, ["text"]),
+            createVNode(unref(_sfc_main$1), {
+              delay: tooltipDelay,
+              text: _ctx.subtitle
+            }, {
+              default: withCtx(() => [
+                _ctx.subtitle ? (openBlock(), createBlock(unref(Text), {
+                  key: 0,
+                  class: "subtitle",
+                  size: "caption",
+                  "is-truncated": ""
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(_ctx.subtitle), 1)
+                  ]),
+                  _: 1
+                })) : createCommentVNode("", true)
+              ]),
+              _: 1
+            }, 8, ["text"])
+          ])
+        ], 2),
+        _ctx.clearable && selected.value ? (openBlock(), createElementBlock("div", _hoisted_5, [
+          createElementVNode("button", {
+            class: "clear-button",
+            onClick: _cache[0] || (_cache[0] = withModifiers(($event) => unref(api).removeSelection(_ctx.option), ["prevent", "stop"]))
+          }, [
+            createVNode(unref(Icon), { name: "close-bold" })
+          ])
+        ])) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+var IncludeExcludeOptionDraggable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-fcdeb5c8"]]);
+
+export { IncludeExcludeOptionDraggable as default };

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

@@ -0,0 +1,23 @@
+import IncludeExclude from './IncludeExclude.vue.js';
+export { default as IncludeExclude } from './IncludeExclude.vue.js';
+import IncludeExcludeOption from './IncludeExcludeOption.vue.js';
+export { default as IncludeExcludeOption } from './IncludeExcludeOption.vue.js';
+import IncludeExcludeOptionDraggable from './IncludeExcludeOptionDraggable.vue.js';
+export { default as IncludeExcludeOptionDraggable } from './IncludeExcludeOptionDraggable.vue.js';
+import IncludeExcludeAppTrigger from './IncludeExcludeAppTrigger.vue.js';
+export { default as IncludeExcludeAppTrigger } from './IncludeExcludeAppTrigger.vue.js';
+import IncludeExcludeAppHeader from './IncludeExcludeAppHeader.vue.js';
+export { default as IncludeExcludeAppHeader } from './IncludeExcludeAppHeader.vue.js';
+import IncludeExcludeChipFilter from './IncludeExcludeChipFilter.vue.js';
+export { default as IncludeExcludeChipFilter } from './IncludeExcludeChipFilter.vue.js';
+
+const IncludeExcludeTypes = () => [
+  IncludeExclude,
+  IncludeExcludeOption,
+  IncludeExcludeOptionDraggable,
+  IncludeExcludeAppTrigger,
+  IncludeExcludeAppHeader,
+  IncludeExcludeChipFilter
+];
+
+export { IncludeExcludeTypes };

package/src/components/input/DollarInput.vue.js

@@ -0,0 +1,38 @@
+import { defineComponent, openBlock, createBlock, mergeProps, withCtx, createVNode, unref, createTextVNode } from 'vue';
+import Input from './Input.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 "../../DollarInput.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "DollarInput",
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const reEmitUpdateEvent = (value) => emit("update:modelValue", value);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Input, mergeProps(props, {
+        type: "number",
+        "hide-number-arrows": true,
+        "onUpdate:modelValue": reEmitUpdateEvent
+      }), {
+        iconBefore: withCtx(() => [
+          createVNode(unref(Text), {
+            class: "dollar-sign",
+            size: "sm"
+          }, {
+            default: withCtx(() => [
+              createTextVNode("$")
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 16);
+    };
+  }
+});
+var DollarInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-16e69452"]]);
+
+export { DollarInput as default };

package/src/components/input/Input.vue.js

@@ -0,0 +1,236 @@
+import { defineComponent, ref, computed, onMounted, nextTick, openBlock, createElementBlock, normalizeClass, createVNode, unref, withCtx, createTextVNode, toDisplayString, createBlock, createCommentVNode, createElementVNode, renderSlot, mergeProps, withKeys, withModifiers } from 'vue';
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import Icon from '../icon/Icon.vue.js';
+import _sfc_main$1 from '../tooltip/Tooltip.vue.js';
+import '../button/Button.vue.js';
+import IconButton from '../button/IconButton.vue.js';
+import '../button/ScrollButton.vue.js';
+import '../table-cells/Editable.vue.js';
+import { useEditableContext } from '../table-cells/EditableContext.vue.js';
+/* empty css                                                       */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Input.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _hoisted_1 = { class: "info-icon-wrapper" };
+const _hoisted_2 = {
+  key: 0,
+  class: "icon-container icon-before"
+};
+const _hoisted_3 = ["value", "placeholder", "disabled", "type", "step", "onKeyup"];
+const _hoisted_4 = {
+  key: 1,
+  class: "icon-container icon-after"
+};
+const _hoisted_5 = { key: 2 };
+const _hoisted_6 = { key: 3 };
+const _hoisted_7 = {
+  key: 1,
+  class: "extra-text-container"
+};
+const __default__ = {
+  inheritAttrs: false
+};
+const _sfc_main = defineComponent({
+  ...__default__,
+  __name: "Input",
+  props: {
+    modelValue: { default: "" },
+    placeholder: { default: "" },
+    disabled: { type: Boolean, default: false },
+    viewOnly: { type: Boolean, default: false },
+    size: { default: "lg" },
+    label: { default: "" },
+    labelDirection: { default: "top" },
+    mandatory: { type: Boolean, default: false },
+    feedbackHelpText: { default: "" },
+    autoFocus: { type: Boolean, default: false },
+    feedbackErrorText: { default: "" },
+    type: { default: "text" },
+    hideNumberArrows: { type: Boolean, default: false },
+    step: { default: 1 },
+    hoverHelpText: { default: "" },
+    hoverHelpTextPlacement: { default: "top" }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const onConfirm = (e) => {
+      api.onClose?.();
+    };
+    const onEnter = () => {
+      if (api?.confirmable && !api?.error?.value) {
+        api.onClose?.();
+      }
+    };
+    const inputRef = ref(null);
+    const isFocused = ref(false);
+    const showLabelInside = computed(() => {
+      return props.label && props.labelDirection === "inside" && !isFocused.value;
+    });
+    const api = useEditableContext();
+    onMounted(async () => {
+      await nextTick();
+      if (!props.autoFocus && !api.focusable) {
+        return;
+      }
+      if (!inputRef.value) {
+        return;
+      }
+      inputRef.value.focus();
+    });
+    const labelText = computed(() => {
+      if (showLabelInside.value) {
+        let label = props.label;
+        if (props.mandatory) {
+          label += " *";
+        }
+        return label;
+      }
+      return props.placeholder;
+    });
+    const sizeClass = computed(() => {
+      return `input-size-${props.size}`;
+    });
+    const handleInput = (event) => {
+      api.onChange?.(event.target.value);
+      emit("update:modelValue", event.target.value);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass({
+          "input-with-label-container": true,
+          "label-direction-left": _ctx.labelDirection === "left",
+          disabled: _ctx.disabled
+        })
+      }, [
+        _ctx.label && _ctx.labelDirection !== "inside" ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: normalizeClass(["label-container", "direction-" + _ctx.labelDirection])
+        }, [
+          createVNode(unref(Text), { class: "label" }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.label), 1)
+            ]),
+            _: 1
+          }),
+          _ctx.mandatory ? (openBlock(), createBlock(unref(Text), {
+            key: 0,
+            size: "lg",
+            class: "mandatory"
+          }, {
+            default: withCtx(() => [
+              createTextVNode("*")
+            ]),
+            _: 1
+          })) : createCommentVNode("", true),
+          _ctx.hoverHelpText ? (openBlock(), createBlock(unref(_sfc_main$1), {
+            key: 1,
+            triggers: ["hover"],
+            text: _ctx.hoverHelpText,
+            placement: _ctx.hoverHelpTextPlacement,
+            size: "xs",
+            strong: true
+          }, {
+            default: withCtx(() => [
+              createElementVNode("div", _hoisted_1, [
+                createVNode(unref(Icon), {
+                  class: "info-icon",
+                  name: "info",
+                  "font-size": "sm"
+                })
+              ])
+            ]),
+            _: 1
+          }, 8, ["text", "placement"])) : createCommentVNode("", true)
+        ], 2)) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: normalizeClass({
+            "input-container": true,
+            "label-inside": showLabelInside.value,
+            error: unref(api).error?.value || _ctx.feedbackErrorText,
+            focused: isFocused.value
+          })
+        }, [
+          _ctx.$slots["iconBefore"] ? (openBlock(), createElementBlock("div", _hoisted_2, [
+            renderSlot(_ctx.$slots, "iconBefore", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          createElementVNode("input", mergeProps(_ctx.$attrs, {
+            ref_key: "inputRef",
+            ref: inputRef,
+            value: unref(api).value?.value ?? _ctx.modelValue,
+            placeholder: labelText.value,
+            disabled: _ctx.disabled || _ctx.viewOnly,
+            type: _ctx.type,
+            class: ["input", {
+              [sizeClass.value]: true,
+              "view-only": _ctx.viewOnly,
+              "label-inside": showLabelInside.value,
+              "hide-arrows": _ctx.hideNumberArrows,
+              "input-type": _ctx.type
+            }],
+            step: _ctx.step,
+            onInput: handleInput,
+            onFocus: _cache[0] || (_cache[0] = ($event) => isFocused.value = true),
+            onBlur: _cache[1] || (_cache[1] = ($event) => isFocused.value = false),
+            onKeyup: withKeys(withModifiers(onEnter, ["prevent"]), ["enter"])
+          }), null, 16, _hoisted_3),
+          _ctx.$slots["iconAfter"] ? (openBlock(), createElementBlock("div", _hoisted_4, [
+            renderSlot(_ctx.$slots, "iconAfter", {}, void 0, true)
+          ])) : createCommentVNode("", true),
+          unref(api)?.confirmable && !unref(api)?.error?.value ? (openBlock(), createElementBlock("div", _hoisted_5, [
+            createVNode(unref(IconButton), {
+              class: "confirm-icon",
+              theme: "secondary",
+              variant: "colorized",
+              onClick: withModifiers(onConfirm, ["stop", "prevent"])
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(Icon), {
+                  name: "check-bold",
+                  "font-size": "sm"
+                })
+              ]),
+              _: 1
+            }, 8, ["onClick"])
+          ])) : createCommentVNode("", true),
+          unref(api)?.error?.value ? (openBlock(), createElementBlock("div", _hoisted_6, [
+            createVNode(unref(_sfc_main$1), {
+              text: unref(api)?.error?.value
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(IconButton), {
+                  class: "error-icon",
+                  theme: "secondary",
+                  variant: "colorized"
+                }, {
+                  default: withCtx(() => [
+                    createVNode(unref(Icon), {
+                      name: "error",
+                      "font-size": "sm"
+                    })
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            }, 8, ["text"])
+          ])) : createCommentVNode("", true)
+        ], 2),
+        _ctx.feedbackErrorText || _ctx.feedbackHelpText ? (openBlock(), createElementBlock("div", _hoisted_7, [
+          createVNode(unref(Text), {
+            class: normalizeClass(_ctx.feedbackErrorText ? "error" : "help"),
+            size: "caption"
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(_ctx.feedbackErrorText || _ctx.feedbackHelpText), 1)
+            ]),
+            _: 1
+          }, 8, ["class"])
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+var Input = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3e4dac7b"]]);
+
+export { Input as default };

package/src/components/input/PasswordInput.vue.js

@@ -0,0 +1,42 @@
+import { defineComponent, ref, openBlock, createBlock, mergeProps, withCtx, createVNode, unref, createTextVNode, toDisplayString } from 'vue';
+import Input from './Input.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 "../../PasswordInput.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "PasswordInput",
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const isPasswordVisible = ref(false);
+    const togglePasswordVisibility = () => {
+      isPasswordVisible.value = !isPasswordVisible.value;
+    };
+    const reEmitUpdateEvent = (value) => emit("update:modelValue", value);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Input, mergeProps(props, {
+        type: isPasswordVisible.value ? "text" : "password",
+        "onUpdate:modelValue": reEmitUpdateEvent
+      }), {
+        iconAfter: withCtx(() => [
+          createVNode(unref(Text), {
+            class: "password-visibility",
+            size: "xs",
+            onClick: togglePasswordVisibility
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(isPasswordVisible.value ? "Hide" : "Show"), 1)
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 16, ["type"]);
+    };
+  }
+});
+var PasswordInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2ae4974c"]]);
+
+export { PasswordInput as default };

package/src/components/input/PercentageInput.vue.js

@@ -0,0 +1,38 @@
+import { defineComponent, openBlock, createBlock, mergeProps, withCtx, createVNode, unref, createTextVNode } from 'vue';
+import Input from './Input.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 "../../PercentageInput.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = defineComponent({
+  __name: "PercentageInput",
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const reEmitUpdateEvent = (value) => emit("update:modelValue", value);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Input, mergeProps(props, {
+        type: "number",
+        "hide-number-arrows": true,
+        "onUpdate:modelValue": reEmitUpdateEvent
+      }), {
+        iconAfter: withCtx(() => [
+          createVNode(unref(Text), {
+            class: "percentage-sign",
+            size: "sm"
+          }, {
+            default: withCtx(() => [
+              createTextVNode("%")
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 16);
+    };
+  }
+});
+var PercentageInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-02484938"]]);
+
+export { PercentageInput as default };

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

@@ -0,0 +1,12 @@
+import Input from './Input.vue.js';
+export { default as Input } from './Input.vue.js';
+import DollarInput from './DollarInput.vue.js';
+export { default as DollarInput } from './DollarInput.vue.js';
+import PercentageInput from './PercentageInput.vue.js';
+export { default as PercentageInput } from './PercentageInput.vue.js';
+import PasswordInput from './PasswordInput.vue.js';
+export { default as PasswordInput } from './PasswordInput.vue.js';
+
+const InputTypes = () => [Input, DollarInput, PercentageInput, PasswordInput];
+
+export { InputTypes };

package/src/components/menu/Menu.vue.js

@@ -0,0 +1,73 @@
+import { defineComponent, ref, computed, openBlock, createBlock, unref, withCtx, createElementVNode, renderSlot } from 'vue';
+import { Dropdown } from 'floating-vue';
+import { onClickOutside } from '@vueuse/core';
+import { useToggle } from '../../composables/useToggle.vue.js';
+/* empty css                                                      *//* empty css                                          */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../Menu.vue_vue_type_style_index_0_scoped_true_lang.css";////import "../../Menu.vue_vue_type_style_index_1_lang.css";
+const _sfc_main = defineComponent({
+  __name: "Menu",
+  props: {
+    isOnTop: { type: Boolean, default: true },
+    distance: { default: 0 },
+    theme: { default: "dropdown" },
+    skidding: { default: 0 },
+    container: { default: "body" }
+  },
+  setup(__props) {
+    const [open, toggle] = useToggle({ initialValue: false });
+    const popup = ref();
+    const triggerRef = ref();
+    const location = computed(() => {
+      return triggerRef.value?.getBoundingClientRect();
+    });
+    const skiddingOffset = computed(() => {
+      if (!popup.value || !triggerRef.value) {
+        return;
+      }
+      const { width: buttonWidth } = triggerRef.value.getBoundingClientRect();
+      return -buttonWidth;
+    });
+    onClickOutside(popup, () => {
+      toggle(false);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Dropdown), {
+        class: "menu",
+        theme: "is-menu",
+        triggers: [],
+        shown: unref(open),
+        placement: "auto-start",
+        container: _ctx.container,
+        flip: "",
+        distance: _ctx.isOnTop ? skiddingOffset.value : _ctx.distance,
+        skidding: _ctx.isOnTop ? -location.value?.height / 2 : _ctx.distance,
+        "auto-hide": false
+      }, {
+        popper: withCtx(() => [
+          createElementVNode("div", {
+            ref_key: "popup",
+            ref: popup,
+            class: "menu-popup",
+            onClick: _cache[1] || (_cache[1] = ($event) => unref(toggle)(false))
+          }, [
+            renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ], 512)
+        ]),
+        default: withCtx(() => [
+          createElementVNode("div", {
+            ref_key: "triggerRef",
+            ref: triggerRef,
+            onClick: _cache[0] || (_cache[0] = ($event) => unref(toggle)())
+          }, [
+            renderSlot(_ctx.$slots, "trigger", {}, void 0, true)
+          ], 512)
+        ]),
+        _: 3
+      }, 8, ["shown", "container", "distance", "skidding"]);
+    };
+  }
+});
+var Menu = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-e5fd59a4"]]);
+
+export { Menu as default };

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

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

package/src/components/menuItem/MenuItem.vue.js

@@ -0,0 +1,31 @@
+import '../typography/Heading.vue.js';
+import Text from '../typography/Text.vue.js';
+import { resolveComponent, openBlock, createElementBlock, createElementVNode, renderSlot, createVNode, withCtx } from 'vue';
+/* empty css                                                          */import _export_sfc from '../../../_virtual/plugin-vue_export-helper.vue.js';
+
+////import "../../MenuItem.vue_vue_type_style_index_0_scoped_true_lang.css";
+const _sfc_main = {
+  components: { Text },
+};
+const _hoisted_1 = { class: "menu-item" };
+const _hoisted_2 = { class: "start-icon" };
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_Text = resolveComponent("Text");
+
+  return (openBlock(), createElementBlock("div", _hoisted_1, [
+    createElementVNode("div", _hoisted_2, [
+      renderSlot(_ctx.$slots, "start-icon", {}, undefined, true)
+    ]),
+    createVNode(_component_Text, { size: "sm" }, {
+      default: withCtx(() => [
+        renderSlot(_ctx.$slots, "default", {}, undefined, true)
+      ]),
+      _: 3
+    }),
+    renderSlot(_ctx.$slots, "end-icon", {}, undefined, true)
+  ]))
+}
+var MenuItem = /*#__PURE__*/_export_sfc(_sfc_main, [['render',_sfc_render],['__scopeId',"data-v-6d064fb9"]]);
+
+export { MenuItem as default };

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

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

package/src/components/popover/Popover.vue.js

@@ -0,0 +1,39 @@
+import { defineComponent, openBlock, createBlock, unref, withCtx, renderSlot } from 'vue';
+import { Dropdown } from 'floating-vue';
+/* empty css                                             */
+////import "../../Popover.vue_vue_type_style_index_0_lang.css";
+const _sfc_main = defineComponent({
+  __name: "Popover",
+  props: {
+    open: { type: Boolean },
+    autoHide: { type: Boolean, default: false },
+    trigger: { default: "click" },
+    disabled: { type: Boolean, default: false },
+    placement: { default: "bottom-start" },
+    distance: { default: 0 },
+    skidding: { default: 0 }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Dropdown), {
+        theme: "custom-popover",
+        placement: _ctx.placement,
+        shown: !!_ctx.open,
+        triggers: _ctx.trigger === "managed" ? [] : [_ctx.trigger],
+        "auto-hide": _ctx.autoHide,
+        distance: _ctx.distance,
+        skidding: _ctx.skidding
+      }, {
+        popper: withCtx(({ hide }) => [
+          renderSlot(_ctx.$slots, "content", { hide })
+        ]),
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "trigger")
+        ]),
+        _: 3
+      }, 8, ["placement", "shown", "triggers", "auto-hide", "distance", "skidding"]);
+    };
+  }
+});
+
+export { _sfc_main as default };