yuang-framework-ui-pc 1.0.20 → 1.1.0

package/lib/ele-edit-tag/index.cjs

@@ -0,0 +1,271 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const EleTooltip = require("../ele-tooltip/index");
+const icons = require("../icons");
+const util = require("../ele-basic-select/util");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleEditTag",
+  components: {
+    ElTag: elementPlus.ElTag,
+    ElInput: elementPlus.ElInput,
+    ElIcon: elementPlus.ElIcon,
+    EleTooltip,
+    PlusOutlined: icons.PlusOutlined,
+    LoadingOutlined: icons.LoadingOutlined
+  },
+  props: props.editTagProps,
+  emits: props.editTagEmits,
+  setup(props2, { emit }) {
+    const { validateChange } = util.useFormValidate();
+    const inputTagRef = vue.ref(null);
+    const inputRef = vue.ref(null);
+    const isEdit = vue.ref(false);
+    const inputValue = vue.ref("");
+    const errorMessage = vue.ref("");
+    const loading = vue.ref(false);
+    const tooltipVisible = vue.ref(false);
+    const isDeactivated = vue.ref(false);
+    const updateModelValue = (modelValue) => {
+      emit("update:modelValue", modelValue);
+      validateChange();
+      emit("change", modelValue);
+    };
+    const addTag = (value) => {
+      tooltipVisible.value = false;
+      isEdit.value = false;
+      updateInputValue("");
+      errorMessage.value = "";
+      loading.value = false;
+      if (value) {
+        const temp = props2.modelValue ? [...props2.modelValue] : [];
+        temp.push(value);
+        updateModelValue(temp);
+      }
+    };
+    const removeTag = (index2) => {
+      if (!props2.modelValue) {
+        return;
+      }
+      const temp = [...props2.modelValue];
+      temp.splice(index2, 1);
+      updateModelValue(temp);
+    };
+    const updateInputValue = (value) => {
+      inputValue.value = value;
+    };
+    const focusInput = () => {
+      setTimeout(() => {
+        inputRef.value && inputRef.value.focus();
+      }, 0);
+    };
+    const handleAddClick = () => {
+      if (props2.disabled) {
+        return;
+      }
+      tooltipVisible.value = false;
+      errorMessage.value = "";
+      isEdit.value = true;
+      vue.nextTick(() => {
+        focusInput();
+      });
+    };
+    const handleTagClose = (index2) => {
+      if (typeof props2.beforeRemove !== "function") {
+        removeTag(index2);
+        return;
+      }
+      const value = props2.modelValue ? props2.modelValue[index2] : void 0;
+      props2.beforeRemove(index2, value).then(() => {
+        removeTag(index2);
+      }).catch(() => {
+      });
+    };
+    const handleInputChange = () => {
+      if (!inputValue.value) {
+        return;
+      }
+      if (typeof props2.validator !== "function") {
+        addTag(inputValue.value);
+        return;
+      }
+      loading.value = true;
+      props2.validator(inputValue.value).then(() => {
+        addTag(inputValue.value);
+      }).catch((e) => {
+        loading.value = false;
+        if (e && e.message != null && e.message !== "") {
+          errorMessage.value = e.message;
+          if (isEdit.value && !isDeactivated.value) {
+            tooltipVisible.value = true;
+          }
+        }
+        vue.nextTick(() => {
+          focusInput();
+        });
+      });
+    };
+    const handleInputBlur = () => {
+      tooltipVisible.value = false;
+      if (!inputValue.value) {
+        isEdit.value = false;
+        errorMessage.value = "";
+      }
+    };
+    const handleInputFocus = () => {
+      if (errorMessage.value && !tooltipVisible.value && isEdit.value && !isDeactivated.value) {
+        tooltipVisible.value = true;
+      }
+    };
+    vue.onDeactivated(() => {
+      isDeactivated.value = true;
+      tooltipVisible.value = false;
+    });
+    vue.onActivated(() => {
+      isDeactivated.value = false;
+    });
+    return {
+      inputTagRef,
+      inputRef,
+      isEdit,
+      inputValue,
+      errorMessage,
+      loading,
+      tooltipVisible,
+      updateInputValue,
+      handleAddClick,
+      handleTagClose,
+      handleInputChange,
+      handleInputBlur,
+      handleInputFocus
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { key: 0 };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElTag = vue.resolveComponent("ElTag");
+  const _component_PlusOutlined = vue.resolveComponent("PlusOutlined");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_LoadingOutlined = vue.resolveComponent("LoadingOutlined");
+  const _component_ElInput = vue.resolveComponent("ElInput");
+  const _component_EleTooltip = vue.resolveComponent("EleTooltip");
+  return vue.openBlock(), vue.createElementBlock("div", {
+    class: vue.normalizeClass([
+      "ele-edit-tag",
+      { "is-large": _ctx.size === "large" },
+      { "is-small": _ctx.size === "small" },
+      { "is-disabled": _ctx.disabled },
+      { "is-readonly": _ctx.readonly }
+    ])
+  }, [
+    _ctx.modelValue ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.modelValue, (item, index2) => {
+      return vue.openBlock(), vue.createBlock(_component_ElTag, {
+        key: index2 + "-" + item,
+        hit: _ctx.hit,
+        type: _ctx.type,
+        color: _ctx.color,
+        size: _ctx.size,
+        effect: _ctx.effect,
+        round: _ctx.round,
+        closable: _ctx.readonly || _ctx.disabled ? false : true,
+        disableTransitions: true,
+        style: vue.normalizeStyle(_ctx.itemStyle),
+        onClose: ($event) => _ctx.handleTagClose(index2)
+      }, {
+        default: vue.withCtx(() => [
+          vue.createTextVNode(vue.toDisplayString(item), 1)
+        ]),
+        _: 2
+      }, 1032, ["hit", "type", "color", "size", "effect", "round", "closable", "style", "onClose"]);
+    }), 128)) : vue.createCommentVNode("", true),
+    !_ctx.readonly ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_ElTag, {
+      key: 1,
+      hit: _ctx.hit,
+      type: "info",
+      size: _ctx.size,
+      round: _ctx.round,
+      disableTransitions: true,
+      class: "ele-edit-tag-add",
+      style: vue.normalizeStyle(_ctx.buttonStyle),
+      onClick: _ctx.handleAddClick
+    }, {
+      default: vue.withCtx(() => [
+        vue.renderSlot(_ctx.$slots, "placeholder", {}, () => [
+          _ctx.placeholder ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1, vue.toDisplayString(_ctx.placeholder), 1)) : (vue.openBlock(), vue.createBlock(_component_ElIcon, {
+            key: 1,
+            class: "ele-edit-tag-add-icon"
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_PlusOutlined)
+            ]),
+            _: 1
+          }))
+        ])
+      ]),
+      _: 3
+    }, 8, ["hit", "size", "round", "style", "onClick"])), [
+      [vue.vShow, !_ctx.isEdit]
+    ]) : vue.createCommentVNode("", true),
+    !_ctx.readonly ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_ElTag, {
+      key: 2,
+      ref: "inputTagRef",
+      size: _ctx.size,
+      round: _ctx.round,
+      disableTransitions: true,
+      class: vue.normalizeClass(["ele-edit-tag-input", { "is-error": !!_ctx.errorMessage }]),
+      style: vue.normalizeStyle(_ctx.inputTagStyle)
+    }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_ElInput, {
+          ref: "inputRef",
+          disabled: _ctx.loading,
+          modelValue: _ctx.inputValue,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.inputValue = $event),
+          validateEvent: false,
+          style: vue.normalizeStyle(_ctx.inputStyle),
+          onChange: _ctx.handleInputChange,
+          onBlur: _ctx.handleInputBlur,
+          onFocus: _ctx.handleInputFocus
+        }, {
+          suffix: vue.withCtx(() => [
+            _ctx.loading ? (vue.openBlock(), vue.createBlock(_component_ElIcon, {
+              key: 0,
+              class: "is-loading"
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(_component_LoadingOutlined)
+              ]),
+              _: 1
+            })) : vue.createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["disabled", "modelValue", "style", "onChange", "onBlur", "onFocus"])
+      ]),
+      _: 1
+    }, 8, ["size", "round", "class", "style"])), [
+      [vue.vShow, _ctx.isEdit]
+    ]) : vue.createCommentVNode("", true),
+    vue.createVNode(_component_EleTooltip, vue.mergeProps({
+      offset: 7,
+      hideAfter: 0,
+      trigger: "click",
+      triggerKeys: [],
+      disabled: !_ctx.tooltipVisible
+    }, _ctx.tooltipProps || {}, {
+      virtualTriggering: true,
+      virtualRef: _ctx.inputTagRef ? _ctx.inputTagRef.$el : void 0,
+      content: _ctx.errorMessage,
+      visible: _ctx.tooltipVisible
+    }), null, 16, ["disabled", "virtualRef", "content", "visible"])
+  ], 2);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

package/lib/ele-edit-tag/index.d.ts

@@ -0,0 +1,65 @@
+import { ElTagInstance, ElInputInstance } from '../ele-app/el';
+
+declare const _default: import('vue').DefineComponent<{
+    modelValue: import('vue').PropType<string[]>;
+    type: import('vue').PropType<import('../ele-app/el').ElTagProps["type"]>;
+    hit: BooleanConstructor;
+    color: StringConstructor;
+    size: import('vue').PropType<import('../ele-app/el').ElTagProps["size"]>;
+    effect: import('vue').PropType<import('../ele-app/el').ElTagProps["effect"]>;
+    round: BooleanConstructor;
+    placeholder: StringConstructor;
+    inputStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    inputTagStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    buttonStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    validator: import('vue').PropType<import('./types').Validator>;
+    beforeRemove: import('vue').PropType<import('./types').BeforeRemove>;
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+}, {
+    inputTagRef: import('vue').Ref<ElTagInstance>;
+    inputRef: import('vue').Ref<ElInputInstance>;
+    isEdit: import('vue').Ref<boolean>;
+    inputValue: import('vue').Ref<string>;
+    errorMessage: import('vue').Ref<string>;
+    loading: import('vue').Ref<boolean>;
+    tooltipVisible: import('vue').Ref<boolean>;
+    updateInputValue: (value: string) => void;
+    handleAddClick: () => void;
+    handleTagClose: (index: number) => void;
+    handleInputChange: () => void;
+    handleInputBlur: () => void;
+    handleInputFocus: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:modelValue': (_value?: string[]) => boolean;
+    change: (_value?: string[]) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: import('vue').PropType<string[]>;
+    type: import('vue').PropType<import('../ele-app/el').ElTagProps["type"]>;
+    hit: BooleanConstructor;
+    color: StringConstructor;
+    size: import('vue').PropType<import('../ele-app/el').ElTagProps["size"]>;
+    effect: import('vue').PropType<import('../ele-app/el').ElTagProps["effect"]>;
+    round: BooleanConstructor;
+    placeholder: StringConstructor;
+    inputStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    inputTagStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    buttonStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
+    validator: import('vue').PropType<import('./types').Validator>;
+    beforeRemove: import('vue').PropType<import('./types').BeforeRemove>;
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+}>> & {
+    "onUpdate:modelValue"?: ((_value?: string[] | undefined) => any) | undefined;
+    onChange?: ((_value?: string[] | undefined) => any) | undefined;
+}, {
+    disabled: boolean;
+    round: boolean;
+    readonly: boolean;
+    hit: boolean;
+}, {}>;
+export default _default;

package/lib/ele-edit-tag/props.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const editTagProps = {
+  /** 标签数据 */
+  modelValue: Array,
+  /** 类型 */
+  type: String,
+  /** 是否有边框描边 */
+  hit: Boolean,
+  /** 颜色 */
+  color: String,
+  /** 尺寸 */
+  size: String,
+  /** 主题 */
+  effect: String,
+  /** 是否为圆形 */
+  round: Boolean,
+  /** 提示文本 */
+  placeholder: String,
+  /** 输入框样式 */
+  inputStyle: Object,
+  /** 输入框外层标签样式 */
+  inputTagStyle: Object,
+  /** 添加按钮样式 */
+  buttonStyle: Object,
+  /** 标签样式 */
+  itemStyle: Object,
+  /** 添加校验方法 */
+  validator: Function,
+  /** 移除校验方法 */
+  beforeRemove: Function,
+  /** 提示属性 */
+  tooltipProps: Object,
+  /** 是否只读 */
+  readonly: Boolean,
+  /** 是否禁用 */
+  disabled: Boolean
+};
+const editTagEmits = {
+  /** 更新数据 */
+  "update:modelValue": (_value) => true,
+  /** 数据改变事件 */
+  change: (_value) => true
+};
+exports.editTagEmits = editTagEmits;
+exports.editTagProps = editTagProps;

package/lib/ele-edit-tag/props.d.ts

@@ -0,0 +1,55 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { StyleValue } from '../ele-app/types';
+import { ElTagProps } from '../ele-app/el';
+import { EleTooltipProps } from '../ele-app/plus';
+import { Validator, BeforeRemove } from './types';
+
+/**
+ * 属性
+ */
+export declare const editTagProps: {
+    /** 标签数据 */
+    modelValue: PropType<string[]>;
+    /** 类型 */
+    type: PropType<ElTagProps["type"]>;
+    /** 是否有边框描边 */
+    hit: BooleanConstructor;
+    /** 颜色 */
+    color: StringConstructor;
+    /** 尺寸 */
+    size: PropType<ElTagProps["size"]>;
+    /** 主题 */
+    effect: PropType<ElTagProps["effect"]>;
+    /** 是否为圆形 */
+    round: BooleanConstructor;
+    /** 提示文本 */
+    placeholder: StringConstructor;
+    /** 输入框样式 */
+    inputStyle: PropType<StyleValue>;
+    /** 输入框外层标签样式 */
+    inputTagStyle: PropType<StyleValue>;
+    /** 添加按钮样式 */
+    buttonStyle: PropType<StyleValue>;
+    /** 标签样式 */
+    itemStyle: PropType<StyleValue>;
+    /** 添加校验方法 */
+    validator: PropType<Validator>;
+    /** 移除校验方法 */
+    beforeRemove: PropType<BeforeRemove>;
+    /** 提示属性 */
+    tooltipProps: PropType<EleTooltipProps>;
+    /** 是否只读 */
+    readonly: BooleanConstructor;
+    /** 是否禁用 */
+    disabled: BooleanConstructor;
+};
+export type EditTagProps = ExtractPropTypes<typeof editTagProps>;
+/**
+ * 事件
+ */
+export declare const editTagEmits: {
+    /** 更新数据 */
+    'update:modelValue': (_value?: string[]) => boolean;
+    /** 数据改变事件 */
+    change: (_value?: string[]) => boolean;
+};

package/lib/ele-edit-tag/style/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+require("element-plus/es/components/tag/style/index");
+require("element-plus/es/components/input/style/index");
+require("element-plus/es/components/icon/style/index");
+require("../../ele-tooltip/style/index");
+require("./index.scss");

package/lib/ele-edit-tag/style/index.d.ts

@@ -0,0 +1 @@
+

package/lib/ele-edit-tag/style/index.scss

@@ -0,0 +1,123 @@
+@use '../../style/themes/default.scss' as *;
+@use '../../style/util.scss' as *;
+
+/* 标签 */
+.ele-edit-tag {
+  margin-top: 8px;
+
+  .el-tag {
+    margin: 0 8px 8px 0;
+    vertical-align: top;
+  }
+}
+
+/* 添加按钮 */
+.ele-edit-tag-add {
+  &.el-tag {
+    cursor: text;
+    margin-right: 0;
+    border-style: dashed;
+    background: none;
+  }
+
+  & > .el-tag__content {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+}
+
+.ele-edit-tag .ele-edit-tag-add-icon {
+  width: 1em;
+  height: 1em;
+  border-radius: 0;
+  font-size: inherit;
+  cursor: inherit;
+  opacity: 0.6;
+}
+
+/* 禁用 */
+.ele-edit-tag.is-disabled .ele-edit-tag-add {
+  cursor: not-allowed;
+  color: elVar('disabled', 'text-color');
+  background: elVar('disabled', 'bg-color');
+  border-color: elVar('disabled', 'border-color');
+}
+
+/* 只读 */
+.ele-edit-tag.is-readonly > .el-tag:last-child {
+  margin-right: 0;
+}
+
+/* 输入框 */
+span.el-tag.ele-edit-tag-input {
+  padding: 0;
+}
+
+.ele-edit-tag-input {
+  &.el-tag {
+    width: 80px;
+    margin-right: 0;
+    display: inline-block;
+    background: none;
+    border: none;
+  }
+
+  & > .el-tag__content {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: inherit;
+    line-height: inherit;
+    border-radius: inherit;
+
+    & > .el-input {
+      flex: 1;
+      width: 100%;
+      height: 100%;
+      font-size: inherit;
+      border-radius: inherit;
+    }
+  }
+
+  .el-input {
+    .el-input__wrapper {
+      height: 100%;
+      padding-left: 8px;
+      padding-right: 8px;
+      box-sizing: border-box;
+      border-radius: inherit;
+    }
+
+    .el-input__inner {
+      height: 100%;
+      line-height: inherit;
+    }
+  }
+
+  &.is-error .el-input .el-input__wrapper {
+    box-shadow: 0 0 0 0.8px elVar('color-danger') inset;
+  }
+}
+
+/* 小尺寸 */
+.ele-edit-tag.is-small .ele-edit-tag-input {
+  width: 60px;
+
+  .el-input .el-input__wrapper {
+    padding-left: 4px;
+    padding-right: 4px;
+  }
+}
+
+/* 大尺寸 */
+.ele-edit-tag.is-large .ele-edit-tag-input {
+  width: 100px;
+
+  .el-input .el-input__wrapper {
+    padding-left: 12px;
+    padding-right: 12px;
+  }
+}

package/lib/ele-edit-tag/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 添加校验方法
+ */
+export type Validator = (value: string) => Promise<void>;
+
+/**
+ * 移除校验方法
+ */
+export type BeforeRemove = (index: number, value?: string) => Promise<void>;

package/lib/ele-ellipsis/index.cjs

@@ -0,0 +1,112 @@
+"use strict";
+const vue = require("vue");
+const core = require("../utils/core");
+const EleTooltip = require("../ele-tooltip/index");
+const EleText = require("../ele-text/index");
+const props$1 = require("../ele-text/props");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleEllipsis",
+  components: { EleText, EleTooltip },
+  props: props.ellipsisProps,
+  setup(props2) {
+    const textRef = vue.ref(null);
+    const virtualRef = vue.ref();
+    const text = vue.ref("");
+    const title = vue.computed(() => {
+      if (!props2.tooltip || typeof props2.tooltip !== "object" || props2.tooltip.original !== true) {
+        return;
+      }
+      return text.value;
+    });
+    const tooltipProps = vue.computed(() => {
+      const isObj = props2.tooltip && props2.tooltip !== true;
+      const opt = isObj ? { ...props2.tooltip } : {};
+      opt.content = text.value;
+      opt.virtualRef = virtualRef.value;
+      opt.virtualTriggering = true;
+      return core.omit(opt, ["original"]);
+    });
+    const multiLine = vue.computed(() => {
+      return !!(props2.maxLine && props2.maxLine > 1);
+    });
+    const textProps = vue.computed(() => {
+      return Object.assign({ title: title.value }, core.pick(props2, props$1.textPropKeys));
+    });
+    const rootStyle = vue.computed(() => {
+      const style = {};
+      const { lineHeight, maxLine } = props2;
+      if (lineHeight != null) {
+        const h = typeof lineHeight === "number" ? `${lineHeight}px` : lineHeight;
+        style.lineHeight = h;
+        if (multiLine.value) {
+          style.height = `calc(${h} * ${maxLine})`;
+        }
+      }
+      if (multiLine.value) {
+        style["-webkit-line-clamp"] = maxLine;
+      }
+      return style;
+    });
+    const handleHover = (e) => {
+      if (!props2.tooltip) {
+        virtualRef.value = void 0;
+        return;
+      }
+      const target = e.currentTarget;
+      if (typeof props2.tooltip === "object" && props2.tooltip.content) {
+        if (text.value !== props2.tooltip.content) {
+          text.value = props2.tooltip.content;
+        }
+      } else {
+        if (target) {
+          const temp = core.contentIsEllipsis(target) ? target.innerText : "";
+          if (text.value !== temp) {
+            text.value = temp;
+          }
+        }
+      }
+      if (text.value && (props2.tooltip === true || !props2.tooltip.original)) {
+        if (virtualRef.value !== target) {
+          virtualRef.value = target;
+        }
+      } else {
+        virtualRef.value = void 0;
+      }
+    };
+    return {
+      textRef,
+      virtualRef,
+      tooltipProps,
+      multiLine,
+      textProps,
+      rootStyle,
+      handleHover
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_EleTooltip = vue.resolveComponent("EleTooltip");
+  const _component_EleText = vue.resolveComponent("EleText");
+  return vue.openBlock(), vue.createBlock(_component_EleText, vue.mergeProps(_ctx.textProps, {
+    ref: "textRef",
+    style: _ctx.rootStyle,
+    class: ["ele-ellipsis", { "is-multi-line": _ctx.multiLine }],
+    onMouseover: _ctx.handleHover
+  }), {
+    default: vue.withCtx(() => [
+      vue.renderSlot(_ctx.$slots, "default"),
+      _ctx.virtualRef ? (vue.openBlock(), vue.createBlock(_component_EleTooltip, vue.normalizeProps(vue.mergeProps({ key: 0 }, _ctx.tooltipProps)), null, 16)) : vue.createCommentVNode("", true)
+    ]),
+    _: 3
+  }, 16, ["style", "class", "onMouseover"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;