yuang-framework-ui-pc 1.0.20 → 1.1.0

package/es/ele-icon-select/components/icon-grid.js

@@ -0,0 +1,126 @@
+import { defineComponent, ref, watch, resolveComponent, openBlock, createBlock, withCtx, createElementVNode, normalizeStyle, createElementBlock, Fragment, renderList, normalizeClass, renderSlot, createVNode, mergeProps, createCommentVNode } from "vue";
+import { ElEmpty, ElScrollbar } from "element-plus";
+import EleTooltip from "../../ele-tooltip/index";
+const _sfc_main = defineComponent({
+  name: "IconGrid",
+  components: { ElEmpty, ElScrollbar, EleTooltip },
+  props: {
+    /** 选中的图标 */
+    icon: String,
+    /** 图标数据 */
+    data: {
+      type: Array,
+      required: true
+    },
+    /** 空组件属性 */
+    emptyProps: Object,
+    /** 是否显示提示 */
+    tooltip: Boolean,
+    /** 提示属性 */
+    tooltipProps: Object,
+    /** 气泡是否展开 */
+    popperVisible: Boolean,
+    /** 网格样式 */
+    gridStyle: Object,
+    /** 图标样式 */
+    itemStyle: Object
+  },
+  emits: {
+    select: (_icon) => true
+  },
+  setup(props, { emit }) {
+    const tooltipVisible = ref(false);
+    const tooltipContent = ref("");
+    const virtualRef = ref();
+    const updateTooltipVisible = (visible) => {
+      tooltipVisible.value = visible;
+    };
+    const hideTooltip = () => {
+      updateTooltipVisible(false);
+    };
+    const handleItemHover = (icon, e) => {
+      if (props.tooltip && props.popperVisible && icon) {
+        virtualRef.value = e.currentTarget;
+        tooltipContent.value = icon;
+        tooltipVisible.value = true;
+      }
+    };
+    const handleItemClick = (icon) => {
+      emit("select", icon);
+    };
+    watch(
+      () => props.popperVisible,
+      (visible) => {
+        if (!visible) {
+          hideTooltip();
+        }
+      }
+    );
+    return {
+      tooltipVisible,
+      tooltipContent,
+      virtualRef,
+      updateTooltipVisible,
+      hideTooltip,
+      handleItemHover,
+      handleItemClick
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = ["title", "onClick", "onMouseover"];
+const _hoisted_2 = {
+  key: 0,
+  class: "ele-icon-select-empty"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElEmpty = resolveComponent("ElEmpty");
+  const _component_EleTooltip = resolveComponent("EleTooltip");
+  const _component_ElScrollbar = resolveComponent("ElScrollbar");
+  return openBlock(), createBlock(_component_ElScrollbar, { class: "ele-icon-select-body" }, {
+    default: withCtx(() => [
+      createElementVNode("div", {
+        class: "ele-icon-select-grid",
+        style: normalizeStyle(_ctx.gridStyle)
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.data, (d, i) => {
+          return openBlock(), createElementBlock("div", {
+            key: i + "-" + d,
+            class: normalizeClass(["ele-icon-select-item", { "is-active": _ctx.icon && d === _ctx.icon }]),
+            title: _ctx.tooltip ? void 0 : d,
+            style: normalizeStyle(_ctx.itemStyle),
+            onClick: ($event) => _ctx.handleItemClick(d),
+            onMouseover: (e) => _ctx.handleItemHover(d, e)
+          }, [
+            renderSlot(_ctx.$slots, "icon", { icon: d })
+          ], 46, _hoisted_1);
+        }), 128))
+      ], 4),
+      !_ctx.data || !_ctx.data.length ? (openBlock(), createElementBlock("div", _hoisted_2, [
+        createVNode(_component_ElEmpty, mergeProps({ imageSize: 60 }, _ctx.emptyProps || {}), null, 16)
+      ])) : createCommentVNode("", true),
+      createVNode(_component_EleTooltip, mergeProps({
+        placement: "top",
+        offset: 6,
+        teleported: false
+      }, _ctx.tooltipProps || {}, {
+        visible: _ctx.tooltipVisible,
+        content: _ctx.tooltipContent,
+        virtualRef: _ctx.virtualRef,
+        virtualTriggering: true,
+        "onUpdate:visible": _ctx.updateTooltipVisible
+      }), null, 16, ["visible", "content", "virtualRef", "onUpdate:visible"])
+    ]),
+    _: 3
+  });
+}
+const iconGrid = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  iconGrid as default
+};

package/es/ele-icon-select/index.d.ts

@@ -0,0 +1,182 @@
+import { StyleValue } from '../ele-app/types';
+import { EleBasicSelectInstance } from '../ele-app/plus';
+import { IconItem } from './types';
+
+declare const _default: import('vue').DefineComponent<{
+    modelValue: StringConstructor;
+    data: {
+        type: import('vue').PropType<string[] | IconItem[]>;
+        required: boolean;
+    };
+    disabled: BooleanConstructor;
+    size: import('vue').PropType<import('../ele-app/el').ElInputProps["size"]>;
+    clearable: BooleanConstructor;
+    placeholder: StringConstructor;
+    automaticDropdown: BooleanConstructor;
+    filterable: import('vue').PropType<boolean | "popper">;
+    teleported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    persistent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placement: {
+        type: import('vue').PropType<import('../ele-app/plus').EleTooltipProps["placement"]>;
+        default: string;
+    };
+    transition: {
+        type: StringConstructor;
+        default: string;
+    };
+    popperOptions: import('vue').PropType<import('../ele-app/plus').EleTooltipProps["popperOptions"]>;
+    popperClass: StringConstructor;
+    popperWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    popperHeight: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    selectStyle: import('vue').PropType<StyleValue>;
+    inputStyle: import('vue').PropType<StyleValue>;
+    selectTagsStyle: import('vue').PropType<StyleValue>;
+    hideOnSingleTab: BooleanConstructor;
+    emptyProps: import('vue').PropType<import('../ele-app/el').ElEmptyProps>;
+    tooltip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    headerStyle: import('vue').PropType<StyleValue>;
+    tabsStyle: import('vue').PropType<StyleValue>;
+    searchStyle: import('vue').PropType<StyleValue>;
+    menusStyle: import('vue').PropType<StyleValue>;
+    bodyStyle: import('vue').PropType<StyleValue>;
+    gridStyle: import('vue').PropType<StyleValue>;
+    itemStyle: import('vue').PropType<StyleValue>;
+    filterPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    responsive: {
+        type: BooleanConstructor;
+        default: null;
+    };
+}, {
+    SearchOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+    selectRef: import('vue').Ref<EleBasicSelectInstance>;
+    selectVisible: import('vue').Ref<boolean>;
+    tabs: import('vue').Ref<string[]>;
+    tabActive: import('vue').Ref<number | undefined>;
+    menus: import('vue').Ref<string[]>;
+    menuActive: import('vue').Ref<number | undefined>;
+    icons: import('vue').Ref<string[]>;
+    keywords: import('vue').Ref<string>;
+    tabBar: import('vue').ComputedRef<boolean>;
+    selectPopperClass: import('vue').ComputedRef<string>;
+    iconPopperStyle: import('vue').ComputedRef<Partial<import('vue').CSSProperties> | undefined>;
+    updatePopover: () => void;
+    updateVisible: (visible: boolean) => void;
+    handleSelectClear: () => void;
+    handleSelectFocus: (e: FocusEvent) => void;
+    handleSelectBlur: (e: FocusEvent) => void;
+    handleSelectFilter: (value: string) => void;
+    handleTabClick: (index: number) => void;
+    handleMenuClick: (index: number) => void;
+    handleIconSelect: (icon: string) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:modelValue': (_value?: string | null) => boolean;
+    change: (_value?: string | null) => boolean;
+    visibleChange: (_visible: boolean) => boolean;
+    clear: () => boolean;
+    focus: (_e: FocusEvent) => boolean;
+    blur: (_e: FocusEvent) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: StringConstructor;
+    data: {
+        type: import('vue').PropType<string[] | IconItem[]>;
+        required: boolean;
+    };
+    disabled: BooleanConstructor;
+    size: import('vue').PropType<import('../ele-app/el').ElInputProps["size"]>;
+    clearable: BooleanConstructor;
+    placeholder: StringConstructor;
+    automaticDropdown: BooleanConstructor;
+    filterable: import('vue').PropType<boolean | "popper">;
+    teleported: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    persistent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placement: {
+        type: import('vue').PropType<import('../ele-app/plus').EleTooltipProps["placement"]>;
+        default: string;
+    };
+    transition: {
+        type: StringConstructor;
+        default: string;
+    };
+    popperOptions: import('vue').PropType<import('../ele-app/plus').EleTooltipProps["popperOptions"]>;
+    popperClass: StringConstructor;
+    popperWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    popperHeight: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    selectStyle: import('vue').PropType<StyleValue>;
+    inputStyle: import('vue').PropType<StyleValue>;
+    selectTagsStyle: import('vue').PropType<StyleValue>;
+    hideOnSingleTab: BooleanConstructor;
+    emptyProps: import('vue').PropType<import('../ele-app/el').ElEmptyProps>;
+    tooltip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    headerStyle: import('vue').PropType<StyleValue>;
+    tabsStyle: import('vue').PropType<StyleValue>;
+    searchStyle: import('vue').PropType<StyleValue>;
+    menusStyle: import('vue').PropType<StyleValue>;
+    bodyStyle: import('vue').PropType<StyleValue>;
+    gridStyle: import('vue').PropType<StyleValue>;
+    itemStyle: import('vue').PropType<StyleValue>;
+    filterPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    responsive: {
+        type: BooleanConstructor;
+        default: null;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((_value?: string | null | undefined) => any) | undefined;
+    onChange?: ((_value?: string | null | undefined) => any) | undefined;
+    onFocus?: ((_e: FocusEvent) => any) | undefined;
+    onBlur?: ((_e: FocusEvent) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onVisibleChange?: ((_visible: boolean) => any) | undefined;
+}, {
+    placement: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, import('element-plus').Placement, unknown> | undefined;
+    teleported: boolean;
+    clearable: boolean;
+    disabled: boolean;
+    persistent: boolean;
+    tooltip: boolean;
+    transition: string;
+    responsive: boolean;
+    automaticDropdown: boolean;
+    popperWidth: string | number;
+    popperHeight: string | number;
+    hideOnSingleTab: boolean;
+    filterPlaceholder: string;
+}, {}>;
+export default _default;

package/es/ele-icon-select/index.js

@@ -0,0 +1,337 @@
+import { defineComponent, ref, computed, watch, resolveComponent, openBlock, createBlock, createSlots, withCtx, createElementVNode, normalizeStyle, createElementBlock, renderSlot, Fragment, renderList, normalizeClass, toDisplayString, createCommentVNode, createVNode, normalizeProps, guardReactiveProps } from "vue";
+import { ElInput } from "element-plus";
+import { useResponsive } from "../ele-pro-layout/util";
+import EleBasicSelect from "../ele-basic-select/index";
+import { useFormValidate, valueIsChanged } from "../ele-basic-select/util";
+import { SearchOutlined } from "../icons";
+import IconGrid from "./components/icon-grid";
+import { iconSelectProps, iconSelectEmits } from "./props";
+const _sfc_main = defineComponent({
+  name: "EleIconSelect",
+  components: { ElInput, EleBasicSelect, IconGrid },
+  props: iconSelectProps,
+  emits: iconSelectEmits,
+  setup(props, { emit }) {
+    const { validateChange } = useFormValidate();
+    const isResponsive = useResponsive(props);
+    const selectRef = ref(null);
+    const selectVisible = ref(false);
+    const tabs = ref([]);
+    const tabActive = ref();
+    const menus = ref([]);
+    const menuActive = ref();
+    const icons = ref([]);
+    const keywords = ref("");
+    const tabBar = computed(() => {
+      if (!tabs.value || !tabs.value.length) {
+        return false;
+      }
+      if (props.hideOnSingleTab && tabs.value.length === 1) {
+        return false;
+      }
+      return true;
+    });
+    const selectPopperClass = computed(() => {
+      const classes = ["ele-icon-select-popper"];
+      if (isResponsive.value) {
+        classes.push("is-responsive");
+      }
+      if (props.popperClass) {
+        classes.push(props.popperClass);
+      }
+      return classes.join(" ");
+    });
+    const iconPopperStyle = computed(() => {
+      if (!props.popperHeight) {
+        return;
+      }
+      return {
+        height: typeof props.popperHeight === "number" ? `${props.popperHeight}px` : props.popperHeight
+      };
+    });
+    const updatePopover = () => {
+      selectRef.value && selectRef.value.updatePopper();
+    };
+    const initData = () => {
+      if (props.data == null || !props.data.length || typeof props.data[0] === "string") {
+        tabs.value = [];
+        menus.value = [];
+        tabActive.value = void 0;
+        menuActive.value = void 0;
+        icons.value = filterData(props.data);
+        return;
+      }
+      tabs.value = props.data.map(
+        (d) => d.title
+      );
+      if (tabActive.value == null || tabActive.value >= tabs.value.length) {
+        tabActive.value = 0;
+      }
+      const data = props.data[tabActive.value];
+      if (typeof data !== "string" && data.children != null && data.children.length) {
+        menus.value = data.children.map((d) => d.title);
+        if (menuActive.value == null || menuActive.value >= menus.value.length) {
+          menuActive.value = 0;
+        }
+        icons.value = filterData(data.children[menuActive.value].icons);
+        return;
+      }
+      menus.value = [];
+      menuActive.value = void 0;
+      icons.value = typeof data !== "string" ? filterData(data.icons) : [];
+    };
+    const filterData = (data) => {
+      if (!data) {
+        return [];
+      }
+      if (!keywords.value) {
+        return data;
+      }
+      const keyword = keywords.value.toLowerCase();
+      return data.filter((t) => t.toLowerCase().includes(keyword));
+    };
+    const updateVisible = (visible) => {
+      if (visible) {
+        handleSelectFilter("");
+      }
+      if (selectVisible.value !== visible) {
+        selectVisible.value = visible;
+        emit("visibleChange", visible);
+      }
+    };
+    const updateModelValue = (modelValue) => {
+      if (valueIsChanged(modelValue, props.modelValue)) {
+        emit("update:modelValue", modelValue);
+        validateChange();
+        emit("change", modelValue);
+      }
+    };
+    const handleSelectClear = () => {
+      updateModelValue(null);
+      updateVisible(false);
+      emit("clear");
+    };
+    const handleSelectFocus = (e) => {
+      emit("focus", e);
+    };
+    const handleSelectBlur = (e) => {
+      emit("blur", e);
+    };
+    const handleSelectFilter = (value) => {
+      var _a;
+      if (keywords.value !== value) {
+        keywords.value = value;
+      }
+      initData();
+      if (!((_a = props.data) == null ? void 0 : _a.length) || icons.value.length) {
+        return;
+      }
+      for (let i = 0; i < props.data.length; i++) {
+        const d = props.data[i];
+        if (typeof d === "string") {
+          return;
+        }
+        const keyword = keywords.value.toLowerCase();
+        if (d.children != null && d.children.length) {
+          for (let j = 0; j < d.children.length; j++) {
+            const icons2 = d.children[j].icons;
+            if (icons2 && icons2.some((t) => t.toLowerCase().includes(keyword))) {
+              menuActive.value = j;
+              tabActive.value = i;
+              initData();
+              return;
+            }
+          }
+        } else if (d.icons != null && d.icons.some((t) => t.toLowerCase().includes(keyword))) {
+          tabActive.value = i;
+          initData();
+          return;
+        }
+      }
+    };
+    const handleTabClick = (index2) => {
+      tabActive.value = index2;
+      initData();
+    };
+    const handleMenuClick = (index2) => {
+      menuActive.value = index2;
+      initData();
+    };
+    const handleIconSelect = (icon) => {
+      updateModelValue(icon);
+      updateVisible(false);
+    };
+    watch(
+      () => props.data,
+      () => {
+        initData();
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    return {
+      SearchOutlined,
+      selectRef,
+      selectVisible,
+      tabs,
+      tabActive,
+      menus,
+      menuActive,
+      icons,
+      keywords,
+      tabBar,
+      selectPopperClass,
+      iconPopperStyle,
+      updatePopover,
+      updateVisible,
+      handleSelectClear,
+      handleSelectFocus,
+      handleSelectBlur,
+      handleSelectFilter,
+      handleTabClick,
+      handleMenuClick,
+      handleIconSelect
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = { class: "ele-icon-select-main" };
+const _hoisted_3 = ["onClick"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElInput = resolveComponent("ElInput");
+  const _component_IconGrid = resolveComponent("IconGrid");
+  const _component_EleBasicSelect = resolveComponent("EleBasicSelect");
+  return openBlock(), createBlock(_component_EleBasicSelect, {
+    ref: "selectRef",
+    value: _ctx.modelValue,
+    multiple: false,
+    disabled: _ctx.disabled,
+    size: _ctx.size,
+    clearable: _ctx.clearable,
+    placeholder: _ctx.placeholder,
+    automaticDropdown: _ctx.automaticDropdown,
+    filterable: typeof _ctx.filterable === "boolean" ? _ctx.filterable : false,
+    teleported: _ctx.teleported,
+    persistent: _ctx.persistent,
+    placement: _ctx.placement,
+    transition: _ctx.transition,
+    popperWidth: _ctx.popperWidth,
+    popperOptions: _ctx.popperOptions,
+    popperClass: _ctx.selectPopperClass,
+    selectClass: "is-icon-select",
+    selectStyle: _ctx.selectStyle,
+    inputStyle: _ctx.inputStyle,
+    selectTagsStyle: _ctx.selectTagsStyle,
+    selectedLabel: _ctx.modelValue,
+    visible: _ctx.selectVisible,
+    "onUpdate:visible": _ctx.updateVisible,
+    onFilterChange: _ctx.handleSelectFilter,
+    onClear: _ctx.handleSelectClear,
+    onFocus: _ctx.handleSelectFocus,
+    onBlur: _ctx.handleSelectBlur
+  }, createSlots({
+    default: withCtx(() => [
+      createElementVNode("div", {
+        class: "ele-icon-select",
+        style: normalizeStyle(_ctx.iconPopperStyle)
+      }, [
+        _ctx.tabBar || _ctx.filterable === "popper" ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: "ele-icon-select-header",
+          style: normalizeStyle(_ctx.headerStyle)
+        }, [
+          renderSlot(_ctx.$slots, "tabLeftExtra"),
+          _ctx.tabBar ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: "ele-icon-select-tabs",
+            style: normalizeStyle(_ctx.tabsStyle)
+          }, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.tabs, (t, i) => {
+              return openBlock(), createElementBlock("div", {
+                key: i + "-" + t,
+                class: normalizeClass(["ele-icon-select-tab", { "is-active": i === _ctx.tabActive }]),
+                onClick: ($event) => _ctx.handleTabClick(i)
+              }, toDisplayString(t), 11, _hoisted_1);
+            }), 128))
+          ], 4)) : createCommentVNode("", true),
+          _ctx.filterable === "popper" ? (openBlock(), createElementBlock("div", {
+            key: 1,
+            class: "ele-icon-select-search",
+            style: normalizeStyle(_ctx.searchStyle)
+          }, [
+            createVNode(_component_ElInput, {
+              size: "small",
+              clearable: true,
+              modelValue: _ctx.keywords,
+              validateEvent: false,
+              prefixIcon: _ctx.SearchOutlined,
+              placeholder: _ctx.filterPlaceholder,
+              "onUpdate:modelValue": _ctx.handleSelectFilter
+            }, null, 8, ["modelValue", "prefixIcon", "placeholder", "onUpdate:modelValue"])
+          ], 4)) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "tabRightExtra")
+        ], 4)) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_2, [
+          _ctx.menus && _ctx.menus.length ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: "ele-icon-select-menus",
+            style: normalizeStyle(_ctx.menusStyle)
+          }, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.menus, (m, i) => {
+              return openBlock(), createElementBlock("div", {
+                key: i + "-" + m,
+                class: normalizeClass(["ele-icon-select-menu", { "is-active": i === _ctx.menuActive }]),
+                onClick: ($event) => _ctx.handleMenuClick(i)
+              }, toDisplayString(m), 11, _hoisted_3);
+            }), 128))
+          ], 4)) : createCommentVNode("", true),
+          createVNode(_component_IconGrid, {
+            data: _ctx.icons,
+            icon: _ctx.modelValue,
+            emptyProps: _ctx.emptyProps,
+            tooltip: _ctx.tooltip,
+            tooltipProps: _ctx.tooltipProps,
+            popperVisible: _ctx.selectVisible,
+            gridStyle: _ctx.gridStyle,
+            itemStyle: _ctx.itemStyle,
+            style: normalizeStyle(_ctx.bodyStyle),
+            onSelect: _ctx.handleIconSelect
+          }, createSlots({ _: 2 }, [
+            _ctx.$slots.icon ? {
+              name: "icon",
+              fn: withCtx((slotProps) => [
+                renderSlot(_ctx.$slots, "icon", normalizeProps(guardReactiveProps(slotProps || {})))
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["data", "icon", "emptyProps", "tooltip", "tooltipProps", "popperVisible", "gridStyle", "itemStyle", "style", "onSelect"])
+        ])
+      ], 4)
+    ]),
+    _: 2
+  }, [
+    _ctx.modelValue && _ctx.$slots.icon ? {
+      name: "prefix",
+      fn: withCtx(() => [
+        renderSlot(_ctx.$slots, "icon", {
+          icon: _ctx.modelValue,
+          prefix: true
+        })
+      ]),
+      key: "0"
+    } : void 0
+  ]), 1032, ["value", "disabled", "size", "clearable", "placeholder", "automaticDropdown", "filterable", "teleported", "persistent", "placement", "transition", "popperWidth", "popperOptions", "popperClass", "selectStyle", "inputStyle", "selectTagsStyle", "selectedLabel", "visible", "onUpdate:visible", "onFilterChange", "onClear", "onFocus", "onBlur"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};