vxe-pc-ui 4.20.34 → 4.20.35

package/lib/tooltip/src/tooltip.js

@@ -64,589 +64,592 @@ function createInternalData() {
     // showDelayTip: undefined
   };
 }
-var tooltip_default = (0, import_comp.defineVxeComponent)({
-  name: "VxeTooltip",
-  props: {
-    modelValue: Boolean,
-    size: {
-      type: String,
-      default: () => getConfig().tooltip.size || getConfig().size
-    },
-    selector: [String, Element],
-    trigger: {
-      type: String,
-      default: () => getConfig().tooltip.trigger || "hover"
-    },
-    theme: {
-      type: String,
-      default: () => getConfig().tooltip.theme || "dark"
-    },
-    content: {
-      type: [String, Number],
-      default: null
-    },
-    useHtml: {
-      type: Boolean,
-      default: () => import_xe_utils.default.isBoolean(getConfig().tooltip.useHtml) ? getConfig().tooltip.useHtml : null
-    },
-    // 已废弃，请使用 useHtml
-    useHTML: {
-      type: Boolean,
-      default: () => getConfig().tooltip.useHTML
-    },
-    zIndex: [String, Number],
-    popupClassName: [String, Function],
-    width: {
-      type: [String, Number],
-      default: () => getConfig().tooltip.Width
-    },
-    height: {
-      type: [String, Number],
-      default: () => getConfig().tooltip.height
-    },
-    minWidth: {
-      type: [String, Number],
-      default: () => getConfig().tooltip.minWidth
-    },
-    minHeight: {
-      type: [String, Number],
-      default: () => getConfig().tooltip.minHeight
-    },
-    maxWidth: {
-      type: [String, Number],
-      default: () => getConfig().tooltip.maxWidth
-    },
-    maxHeight: {
-      type: [String, Number],
-      default: () => getConfig().tooltip.maxHeight
-    },
-    placement: {
-      type: String,
-      default: () => getConfig().tooltip.placement
-    },
-    defaultPlacement: {
-      type: String,
-      default: () => getConfig().tooltip.defaultPlacement
-    },
-    isArrow: {
-      type: Boolean,
-      default: () => getConfig().tooltip.isArrow
-    },
-    enterable: {
-      type: Boolean,
-      default: () => getConfig().tooltip.enterable
-    },
-    enterDelay: {
-      type: Number,
-      default: () => getConfig().tooltip.enterDelay
-    },
-    leaveDelay: {
-      type: Number,
-      default: () => getConfig().tooltip.leaveDelay
-    },
-    appendTo: {
-      type: [String, Function],
-      default: () => getConfig().tooltip.appendTo
-    },
-    useScrollbar: {
-      type: Boolean,
-      default: () => getDefVal(getConfig().tooltip.useScrollbar, getConfig().useScrollbar)
+var tooltip_default = (
+  /* define-vxe-component start */
+  (0, import_comp.defineVxeComponent)({
+    name: "VxeTooltip",
+    props: {
+      modelValue: Boolean,
+      size: {
+        type: String,
+        default: () => getConfig().tooltip.size || getConfig().size
+      },
+      selector: [String, Element],
+      trigger: {
+        type: String,
+        default: () => getConfig().tooltip.trigger || "hover"
+      },
+      theme: {
+        type: String,
+        default: () => getConfig().tooltip.theme || "dark"
+      },
+      content: {
+        type: [String, Number],
+        default: null
+      },
+      useHtml: {
+        type: Boolean,
+        default: () => import_xe_utils.default.isBoolean(getConfig().tooltip.useHtml) ? getConfig().tooltip.useHtml : null
+      },
+      // 已废弃，请使用 useHtml
+      useHTML: {
+        type: Boolean,
+        default: () => getConfig().tooltip.useHTML
+      },
+      zIndex: [String, Number],
+      popupClassName: [String, Function],
+      width: {
+        type: [String, Number],
+        default: () => getConfig().tooltip.Width
+      },
+      height: {
+        type: [String, Number],
+        default: () => getConfig().tooltip.height
+      },
+      minWidth: {
+        type: [String, Number],
+        default: () => getConfig().tooltip.minWidth
+      },
+      minHeight: {
+        type: [String, Number],
+        default: () => getConfig().tooltip.minHeight
+      },
+      maxWidth: {
+        type: [String, Number],
+        default: () => getConfig().tooltip.maxWidth
+      },
+      maxHeight: {
+        type: [String, Number],
+        default: () => getConfig().tooltip.maxHeight
+      },
+      placement: {
+        type: String,
+        default: () => getConfig().tooltip.placement
+      },
+      defaultPlacement: {
+        type: String,
+        default: () => getConfig().tooltip.defaultPlacement
+      },
+      isArrow: {
+        type: Boolean,
+        default: () => getConfig().tooltip.isArrow
+      },
+      enterable: {
+        type: Boolean,
+        default: () => getConfig().tooltip.enterable
+      },
+      enterDelay: {
+        type: Number,
+        default: () => getConfig().tooltip.enterDelay
+      },
+      leaveDelay: {
+        type: Number,
+        default: () => getConfig().tooltip.leaveDelay
+      },
+      appendTo: {
+        type: [String, Function],
+        default: () => getConfig().tooltip.appendTo
+      },
+      useScrollbar: {
+        type: Boolean,
+        default: () => getDefVal(getConfig().tooltip.useScrollbar, getConfig().useScrollbar)
+      },
+      scrollbarConfig: Object
     },
-    scrollbarConfig: Object
-  },
-  emits: ["update:modelValue", "show", "hide"],
-  setup(props, context) {
-    const { slots, emit } = context;
-    const xID = import_xe_utils.default.uniqueId();
-    const { computeSize } = useFns.useSize(props);
-    const { computeIsVScrollbar } = useFns.useVScrollbar(props);
-    const reactData = (0, import_vue.reactive)(createReactData());
-    const internalData = createInternalData();
-    const refElem = (0, import_vue.ref)();
-    const contentScrollbar = (0, import_vue.ref)();
-    const contentWrapperElem = (0, import_vue.ref)();
-    const computeWrapperStyle = (0, import_vue.computed)(() => {
-      const { width, height, minHeight, minWidth, maxHeight, maxWidth } = props;
-      const stys = {};
-      if (width) {
-        stys.width = (0, import_dom.toCssUnit)(width);
-      }
-      if (height) {
-        stys.height = (0, import_dom.toCssUnit)(height);
-      }
-      if (minWidth) {
-        stys.minWidth = (0, import_dom.toCssUnit)(minWidth);
-      }
-      if (minHeight) {
-        stys.minHeight = (0, import_dom.toCssUnit)(minHeight);
-      }
-      if (maxWidth) {
-        stys.maxWidth = (0, import_dom.toCssUnit)(maxWidth);
-      }
-      if (maxHeight) {
-        stys.maxHeight = (0, import_dom.toCssUnit)(maxHeight);
-      }
-      return stys;
-    });
-    const refMaps = {
-      refElem
-    };
-    const $xeTooltip = {
-      xID,
-      props,
-      context,
-      reactData,
-      internalData,
-      getRefMaps: () => refMaps
-    };
-    const dispatchEvent = (type, params, evnt) => {
-      emit(type, createEvent(evnt, { $tooltip: $xeTooltip }, params));
-    };
-    const updateValue = (value) => {
-      if (value !== reactData.visible) {
-        reactData.visible = value;
-        reactData.isUpdate = true;
-        emit("update:modelValue", value);
-      }
-    };
-    const updateZIndex = () => {
-      const { zIndex } = props;
-      if (zIndex) {
-        reactData.tipZindex = import_xe_utils.default.toNumber(zIndex);
-      } else if (reactData.tipZindex < (0, import_utils.getLastZIndex)()) {
-        reactData.tipZindex = (0, import_utils.nextZIndex)();
-      }
-    };
-    const clickEvent = () => {
-      if (reactData.visible) {
-        $xeTooltip.close();
-      } else {
-        handleVisible(reactData.target || getSelectorEl(), props.content);
-      }
-    };
-    const targetMouseenterEvent = () => {
-      handleVisible(reactData.target || getSelectorEl(), props.content);
-    };
-    const targetMouseleaveEvent = () => {
-      const { trigger, enterable, leaveDelay } = props;
-      reactData.tipActive = false;
-      if (enterable && trigger === "hover") {
-        setTimeout(() => {
-          if (!reactData.tipActive) {
-            $xeTooltip.close();
-          }
-        }, leaveDelay);
-      } else {
-        $xeTooltip.close();
-      }
-    };
-    const wrapperMouseenterEvent = () => {
-      reactData.tipActive = true;
-    };
-    const wrapperMouseleaveEvent = () => {
-      const { trigger, enterable, leaveDelay } = props;
-      reactData.tipActive = false;
-      if (enterable && trigger === "hover") {
-        setTimeout(() => {
-          if (!reactData.tipActive) {
-            $xeTooltip.close();
-          }
-        }, leaveDelay);
-      }
-    };
-    const showTip = () => {
-      const { appendTo } = props;
-      const { tipStore } = reactData;
-      const panelElem = refElem.value;
-      if (panelElem) {
-        const parentNode = panelElem.parentNode;
-        if (!parentNode) {
-          (0, import_dom.getPopupAppendElement)(appendTo).appendChild(panelElem);
+    emits: ["update:modelValue", "show", "hide"],
+    setup(props, context) {
+      const { slots, emit } = context;
+      const xID = import_xe_utils.default.uniqueId();
+      const { computeSize } = useFns.useSize(props);
+      const { computeIsVScrollbar } = useFns.useVScrollbar(props);
+      const reactData = (0, import_vue.reactive)(createReactData());
+      const internalData = createInternalData();
+      const refElem = (0, import_vue.ref)();
+      const contentScrollbar = (0, import_vue.ref)();
+      const contentWrapperElem = (0, import_vue.ref)();
+      const computeWrapperStyle = (0, import_vue.computed)(() => {
+        const { width, height, minHeight, minWidth, maxHeight, maxWidth } = props;
+        const stys = {};
+        if (width) {
+          stys.width = (0, import_dom.toCssUnit)(width);
+        }
+        if (height) {
+          stys.height = (0, import_dom.toCssUnit)(height);
+        }
+        if (minWidth) {
+          stys.minWidth = (0, import_dom.toCssUnit)(minWidth);
         }
-      }
-      updateValue(true);
-      updateZIndex();
-      tipStore.placement = "top";
-      tipStore.style = { width: "auto", left: 0, top: 0, zIndex: props.zIndex || reactData.tipZindex };
-      tipStore.arrowStyle = { left: "50%" };
-      return $xeTooltip.updatePlacement().then(() => {
-        return $xeTooltip.updatePlacement();
+        if (minHeight) {
+          stys.minHeight = (0, import_dom.toCssUnit)(minHeight);
+        }
+        if (maxWidth) {
+          stys.maxWidth = (0, import_dom.toCssUnit)(maxWidth);
+        }
+        if (maxHeight) {
+          stys.maxHeight = (0, import_dom.toCssUnit)(maxHeight);
+        }
+        return stys;
       });
-    };
-    const handleDelayFn = () => {
-      internalData.showDelayTip = import_xe_utils.default.debounce(
-        () => {
-          if (reactData.tipActive) {
-            showTip();
-          }
-        },
-        props.enterDelay,
-        { leading: false, trailing: true }
-      );
-    };
-    const handleVisible = (target, content, evnt) => {
-      const contentSlot = slots.content;
-      if (!contentSlot && (content === "" || import_xe_utils.default.eqNull(content))) {
-        return (0, import_vue.nextTick)();
-      }
-      if (target) {
-        const { showDelayTip } = internalData;
-        const { trigger, enterDelay } = props;
-        if (evnt) {
-          reactData.tipPos = {
-            x: evnt.clientX,
-            y: evnt.clientY,
-            oLeft: evnt.offsetX,
-            oTop: evnt.offsetY
-          };
+      const refMaps = {
+        refElem
+      };
+      const $xeTooltip = {
+        xID,
+        props,
+        context,
+        reactData,
+        internalData,
+        getRefMaps: () => refMaps
+      };
+      const dispatchEvent = (type, params, evnt) => {
+        emit(type, createEvent(evnt, { $tooltip: $xeTooltip }, params));
+      };
+      const updateValue = (value) => {
+        if (value !== reactData.visible) {
+          reactData.visible = value;
+          reactData.isUpdate = true;
+          emit("update:modelValue", value);
+        }
+      };
+      const updateZIndex = () => {
+        const { zIndex } = props;
+        if (zIndex) {
+          reactData.tipZindex = import_xe_utils.default.toNumber(zIndex);
+        } else if (reactData.tipZindex < (0, import_utils.getLastZIndex)()) {
+          reactData.tipZindex = (0, import_utils.nextZIndex)();
+        }
+      };
+      const clickEvent = () => {
+        if (reactData.visible) {
+          $xeTooltip.close();
         } else {
-          reactData.tipPos = null;
+          handleVisible(reactData.target || getSelectorEl(), props.content);
+        }
+      };
+      const targetMouseenterEvent = () => {
+        handleVisible(reactData.target || getSelectorEl(), props.content);
+      };
+      const targetMouseleaveEvent = () => {
+        const { trigger, enterable, leaveDelay } = props;
+        reactData.tipActive = false;
+        if (enterable && trigger === "hover") {
+          setTimeout(() => {
+            if (!reactData.tipActive) {
+              $xeTooltip.close();
+            }
+          }, leaveDelay);
+        } else {
+          $xeTooltip.close();
         }
+      };
+      const wrapperMouseenterEvent = () => {
         reactData.tipActive = true;
-        reactData.tipTarget = target;
-        reactData.tipContent = content;
-        if (reactData.visible) {
-          return $xeTooltip.updatePlacement();
+      };
+      const wrapperMouseleaveEvent = () => {
+        const { trigger, enterable, leaveDelay } = props;
+        reactData.tipActive = false;
+        if (enterable && trigger === "hover") {
+          setTimeout(() => {
+            if (!reactData.tipActive) {
+              $xeTooltip.close();
+            }
+          }, leaveDelay);
         }
-        if (enterDelay && trigger === "hover") {
-          if (showDelayTip) {
-            showDelayTip();
+      };
+      const showTip = () => {
+        const { appendTo } = props;
+        const { tipStore } = reactData;
+        const panelElem = refElem.value;
+        if (panelElem) {
+          const parentNode = panelElem.parentNode;
+          if (!parentNode) {
+            (0, import_dom.getPopupAppendElement)(appendTo).appendChild(panelElem);
           }
-          dispatchEvent("show", {}, evnt || null);
-        } else {
-          const rest = showTip();
-          dispatchEvent("show", {}, evnt || null);
-          return rest;
         }
-      }
-      return (0, import_vue.nextTick)();
-    };
-    const getSelectorEl = () => {
-      const { selector } = props;
-      if (selector) {
-        if (import_xe_utils.default.isElement(selector)) {
-          return selector;
+        updateValue(true);
+        updateZIndex();
+        tipStore.placement = "top";
+        tipStore.style = { width: "auto", left: 0, top: 0, zIndex: props.zIndex || reactData.tipZindex };
+        tipStore.arrowStyle = { left: "50%" };
+        return $xeTooltip.updatePlacement().then(() => {
+          return $xeTooltip.updatePlacement();
+        });
+      };
+      const handleDelayFn = () => {
+        internalData.showDelayTip = import_xe_utils.default.debounce(
+          () => {
+            if (reactData.tipActive) {
+              showTip();
+            }
+          },
+          props.enterDelay,
+          { leading: false, trailing: true }
+        );
+      };
+      const handleVisible = (target, content, evnt) => {
+        const contentSlot = slots.content;
+        if (!contentSlot && (content === "" || import_xe_utils.default.eqNull(content))) {
+          return (0, import_vue.nextTick)();
         }
-        if (import_xe_utils.default.isString(selector)) {
-          return document.querySelector(selector);
+        if (target) {
+          const { showDelayTip } = internalData;
+          const { trigger, enterDelay } = props;
+          if (evnt) {
+            reactData.tipPos = {
+              x: evnt.clientX,
+              y: evnt.clientY,
+              oLeft: evnt.offsetX,
+              oTop: evnt.offsetY
+            };
+          } else {
+            reactData.tipPos = null;
+          }
+          reactData.tipActive = true;
+          reactData.tipTarget = target;
+          reactData.tipContent = content;
+          if (reactData.visible) {
+            return $xeTooltip.updatePlacement();
+          }
+          if (enterDelay && trigger === "hover") {
+            if (showDelayTip) {
+              showDelayTip();
+            }
+            dispatchEvent("show", {}, evnt || null);
+          } else {
+            const rest = showTip();
+            dispatchEvent("show", {}, evnt || null);
+            return rest;
+          }
         }
-      }
-      return null;
-    };
-    const updateTipStyle = () => {
-      const { placement, defaultPlacement, appendTo, isArrow } = props;
-      const { tipTarget: targetElem, tipStore, tipPos, tipZindex } = reactData;
-      const panelElem = refElem.value;
-      if (!targetElem || !panelElem) {
         return (0, import_vue.nextTick)();
-      }
-      const targetRect = targetElem.getBoundingClientRect();
-      const targetWidth = targetElem.offsetWidth;
-      const targetHeight = targetElem.offsetHeight;
-      const panelWidth = panelElem.offsetWidth;
-      const targetLeft = targetRect.left;
-      const targetTop = targetRect.top;
-      let left = 0;
-      let top = 0;
-      if (tipPos && (tipPos.oLeft || tipPos.oTop)) {
-        left = targetLeft;
-        top = targetTop + targetHeight;
-        if (isArrow) {
-          left = left + Math.max(8, Math.min(targetWidth - 8, tipPos.oLeft)) - panelWidth / 2;
-        } else {
-          left = tipPos.x + 1;
-          top = tipPos.y + 1;
+      };
+      const getSelectorEl = () => {
+        const { selector } = props;
+        if (selector) {
+          if (import_xe_utils.default.isElement(selector)) {
+            return selector;
+          }
+          if (import_xe_utils.default.isString(selector)) {
+            return document.querySelector(selector);
+          }
         }
-      }
-      const ppObj = (0, import_dom.updatePanelPlacement)(targetElem, panelElem, {
-        defaultTop: top,
-        defaultLeft: left,
-        placement,
-        defaultPlacement,
-        appendTo,
-        isMinWidth: false,
-        teleportTo: true
-      });
-      const panelStyle = Object.assign(ppObj.style, {
-        zIndex: tipZindex
-      });
-      tipStore.placement = ppObj.placement;
-      tipStore.style = panelStyle;
-      tipStore.arrowStyle.left = ppObj.arrowLeft ? `${ppObj.arrowLeft}px` : "";
-      return (0, import_vue.nextTick)();
-    };
-    const tooltipMethods = {
-      dispatchEvent,
-      openByEvent(evnt, target, content) {
-        return handleVisible(target || reactData.target || getSelectorEl(), content, evnt);
-      },
-      open(target, content) {
-        return handleVisible(target || reactData.target || getSelectorEl(), content);
-      },
-      close() {
-        reactData.tipPos = null;
-        reactData.tipTarget = null;
-        reactData.tipActive = false;
-        Object.assign(reactData.tipStore, {
-          style: {},
-          placement: "",
-          arrowStyle: null
+        return null;
+      };
+      const updateTipStyle = () => {
+        const { placement, defaultPlacement, appendTo, isArrow } = props;
+        const { tipTarget: targetElem, tipStore, tipPos, tipZindex } = reactData;
+        const panelElem = refElem.value;
+        if (!targetElem || !panelElem) {
+          return (0, import_vue.nextTick)();
+        }
+        const targetRect = targetElem.getBoundingClientRect();
+        const targetWidth = targetElem.offsetWidth;
+        const targetHeight = targetElem.offsetHeight;
+        const panelWidth = panelElem.offsetWidth;
+        const targetLeft = targetRect.left;
+        const targetTop = targetRect.top;
+        let left = 0;
+        let top = 0;
+        if (tipPos && (tipPos.oLeft || tipPos.oTop)) {
+          left = targetLeft;
+          top = targetTop + targetHeight;
+          if (isArrow) {
+            left = left + Math.max(8, Math.min(targetWidth - 8, tipPos.oLeft)) - panelWidth / 2;
+          } else {
+            left = tipPos.x + 1;
+            top = tipPos.y + 1;
+          }
+        }
+        const ppObj = (0, import_dom.updatePanelPlacement)(targetElem, panelElem, {
+          defaultTop: top,
+          defaultLeft: left,
+          placement,
+          defaultPlacement,
+          appendTo,
+          isMinWidth: false,
+          teleportTo: true
         });
-        updateValue(false);
-        dispatchEvent("hide", {}, null);
-        return (0, import_vue.nextTick)();
-      },
-      toVisible(target, content) {
-        return handleVisible(target, content);
-      },
-      updatePlacement() {
-        return updateTipStyle().then(() => {
-          return updateTipStyle();
-        }).then(() => {
-          return updateTipStyle();
+        const panelStyle = Object.assign(ppObj.style, {
+          zIndex: tipZindex
         });
-      },
-      isActived() {
-        return reactData.tipActive;
-      },
-      setActived(active) {
-        reactData.tipActive = !!active;
-      }
-    };
-    const wheelEvent = (evnt) => {
-      evnt.stopPropagation();
-    };
-    const handleGlobalScrollEvent = () => {
-      if (reactData.visible) {
-        $xeTooltip.updatePlacement();
-      }
-    };
-    const handleGlobalBlurEvent = () => {
-      $xeTooltip.close();
-    };
-    const tooltipPrivateMethods = {
-      handleCloseEvent: targetMouseleaveEvent
-    };
-    Object.assign($xeTooltip, tooltipMethods, tooltipPrivateMethods);
-    const renderContent = () => {
-      const { theme, useHtml, useHTML } = props;
-      const { tipContent } = reactData;
-      const isVScrollbar = computeIsVScrollbar.value;
-      const wrapperStyle = computeWrapperStyle.value;
-      const contentSlot = slots.content;
-      const contVNs = [];
-      if (contentSlot) {
-        contVNs.push(
-          (0, import_vue.h)(
-            "div",
+        tipStore.placement = ppObj.placement;
+        tipStore.style = panelStyle;
+        tipStore.arrowStyle.left = ppObj.arrowLeft ? `${ppObj.arrowLeft}px` : "";
+        return (0, import_vue.nextTick)();
+      };
+      const tooltipMethods = {
+        dispatchEvent,
+        openByEvent(evnt, target, content) {
+          return handleVisible(target || reactData.target || getSelectorEl(), content, evnt);
+        },
+        open(target, content) {
+          return handleVisible(target || reactData.target || getSelectorEl(), content);
+        },
+        close() {
+          reactData.tipPos = null;
+          reactData.tipTarget = null;
+          reactData.tipActive = false;
+          Object.assign(reactData.tipStore, {
+            style: {},
+            placement: "",
+            arrowStyle: null
+          });
+          updateValue(false);
+          dispatchEvent("hide", {}, null);
+          return (0, import_vue.nextTick)();
+        },
+        toVisible(target, content) {
+          return handleVisible(target, content);
+        },
+        updatePlacement() {
+          return updateTipStyle().then(() => {
+            return updateTipStyle();
+          }).then(() => {
+            return updateTipStyle();
+          });
+        },
+        isActived() {
+          return reactData.tipActive;
+        },
+        setActived(active) {
+          reactData.tipActive = !!active;
+        }
+      };
+      const wheelEvent = (evnt) => {
+        evnt.stopPropagation();
+      };
+      const handleGlobalScrollEvent = () => {
+        if (reactData.visible) {
+          $xeTooltip.updatePlacement();
+        }
+      };
+      const handleGlobalBlurEvent = () => {
+        $xeTooltip.close();
+      };
+      const tooltipPrivateMethods = {
+        handleCloseEvent: targetMouseleaveEvent
+      };
+      Object.assign($xeTooltip, tooltipMethods, tooltipPrivateMethods);
+      const renderContent = () => {
+        const { theme, useHtml, useHTML } = props;
+        const { tipContent } = reactData;
+        const isVScrollbar = computeIsVScrollbar.value;
+        const wrapperStyle = computeWrapperStyle.value;
+        const contentSlot = slots.content;
+        const contVNs = [];
+        if (contentSlot) {
+          contVNs.push(
+            (0, import_vue.h)(
+              "div",
+              {
+                key: "ct"
+              },
+              (0, import_vn.getSlotVNs)(contentSlot({}))
+            )
+          );
+        } else if (import_xe_utils.default.isBoolean(useHtml) ? useHtml : useHTML) {
+          contVNs.push(
+            (0, import_vue.h)("div", {
+              key: "ch",
+              innerHTML: tipContent
+            })
+          );
+        } else {
+          contVNs.push(
+            (0, import_vue.h)(
+              "span",
+              {
+                key: "cd"
+              },
+              `${tipContent}`
+            )
+          );
+        }
+        if (isVScrollbar) {
+          return (0, import_vue.h)(
+            import_scrollbar.default,
             {
-              key: "ct"
+              key: 5,
+              ref: contentScrollbar,
+              class: "vxe-tooltip--scrollbar-content",
+              theme,
+              viewClassName: "vxe-tooltip--scrollbar-content-view",
+              viewInnerClassName: "vxe-tooltip--scrollbar-content-inner",
+              viewStyle: wrapperStyle
             },
-            (0, import_vn.getSlotVNs)(contentSlot({}))
-          )
-        );
-      } else if (import_xe_utils.default.isBoolean(useHtml) ? useHtml : useHTML) {
-        contVNs.push(
-          (0, import_vue.h)("div", {
-            key: "ch",
-            innerHTML: tipContent
-          })
-        );
-      } else {
-        contVNs.push(
-          (0, import_vue.h)(
-            "span",
             {
-              key: "cd"
-            },
-            `${tipContent}`
-          )
-        );
-      }
-      if (isVScrollbar) {
+              default: () => contVNs
+            }
+          );
+        }
         return (0, import_vue.h)(
-          import_scrollbar.default,
+          "div",
           {
-            key: 5,
-            ref: contentScrollbar,
-            class: "vxe-tooltip--scrollbar-content",
-            theme,
-            viewClassName: "vxe-tooltip--scrollbar-content-view",
-            viewInnerClassName: "vxe-tooltip--scrollbar-content-inner",
-            viewStyle: wrapperStyle
+            key: 3,
+            ref: contentWrapperElem,
+            class: "vxe-tooltip--content",
+            style: wrapperStyle
           },
+          contVNs
+        );
+      };
+      const renderVN = () => {
+        const { popupClassName, theme, isArrow, enterable } = props;
+        const { tipActive, visible, tipStore } = reactData;
+        const defaultSlot = slots.default;
+        const vSize = computeSize.value;
+        let ons;
+        if (enterable) {
+          ons = {
+            onMouseenter: wrapperMouseenterEvent,
+            onMouseleave: wrapperMouseleaveEvent
+          };
+        }
+        return (0, import_vue.h)(
+          "div",
           {
-            default: () => contVNs
-          }
+            ref: refElem,
+            class: [
+              "vxe-tooltip--wrapper",
+              `theme--${theme}`,
+              popupClassName ? import_xe_utils.default.isFunction(popupClassName) ? popupClassName({ $tooltip: $xeTooltip }) : popupClassName : "",
+              {
+                [`size--${vSize}`]: vSize,
+                [`placement--${tipStore.placement}`]: tipStore.placement,
+                "is--enterable": enterable,
+                "is--visible": visible,
+                "is--arrow": isArrow,
+                "is--active": tipActive
+              }
+            ],
+            style: tipStore.style,
+            ...ons
+          },
+          [
+            (0, import_vue.h)(
+              "div",
+              {
+                key: "tby",
+                class: "vxe-tooltip--body"
+              },
+              [
+                renderContent(),
+                (0, import_vue.h)("div", {
+                  class: "vxe-tooltip--arrow",
+                  style: tipStore.arrowStyle
+                })
+              ]
+            ),
+            ...defaultSlot ? (0, import_vn.getSlotVNs)(defaultSlot({})) : []
+          ]
         );
-      }
-      return (0, import_vue.h)(
-        "div",
-        {
-          key: 3,
-          ref: contentWrapperElem,
-          class: "vxe-tooltip--content",
-          style: wrapperStyle
-        },
-        contVNs
+      };
+      (0, import_vue.watch)(
+        () => props.enterDelay,
+        () => {
+          handleDelayFn();
+        }
       );
-    };
-    const renderVN = () => {
-      const { popupClassName, theme, isArrow, enterable } = props;
-      const { tipActive, visible, tipStore } = reactData;
-      const defaultSlot = slots.default;
-      const vSize = computeSize.value;
-      let ons;
-      if (enterable) {
-        ons = {
-          onMouseenter: wrapperMouseenterEvent,
-          onMouseleave: wrapperMouseleaveEvent
-        };
-      }
-      return (0, import_vue.h)(
-        "div",
-        {
-          ref: refElem,
-          class: [
-            "vxe-tooltip--wrapper",
-            `theme--${theme}`,
-            popupClassName ? import_xe_utils.default.isFunction(popupClassName) ? popupClassName({ $tooltip: $xeTooltip }) : popupClassName : "",
-            {
-              [`size--${vSize}`]: vSize,
-              [`placement--${tipStore.placement}`]: tipStore.placement,
-              "is--enterable": enterable,
-              "is--visible": visible,
-              "is--arrow": isArrow,
-              "is--active": tipActive
+      (0, import_vue.watch)(
+        () => props.content,
+        (val) => {
+          reactData.tipContent = val;
+        }
+      );
+      (0, import_vue.watch)(
+        () => props.modelValue,
+        (val) => {
+          if (!reactData.isUpdate) {
+            if (val) {
+              handleVisible(reactData.target || getSelectorEl(), props.content);
+            } else {
+              $xeTooltip.close();
             }
-          ],
-          style: tipStore.style,
-          ...ons
-        },
-        [
-          (0, import_vue.h)(
-            "div",
-            {
-              key: "tby",
-              class: "vxe-tooltip--body"
-            },
-            [
-              renderContent(),
-              (0, import_vue.h)("div", {
-                class: "vxe-tooltip--arrow",
-                style: tipStore.arrowStyle
-              })
-            ]
-          ),
-          ...defaultSlot ? (0, import_vn.getSlotVNs)(defaultSlot({})) : []
-        ]
+          }
+          reactData.isUpdate = false;
+        }
       );
-    };
-    (0, import_vue.watch)(
-      () => props.enterDelay,
-      () => {
-        handleDelayFn();
-      }
-    );
-    (0, import_vue.watch)(
-      () => props.content,
-      (val) => {
-        reactData.tipContent = val;
-      }
-    );
-    (0, import_vue.watch)(
-      () => props.modelValue,
-      (val) => {
-        if (!reactData.isUpdate) {
-          if (val) {
-            handleVisible(reactData.target || getSelectorEl(), props.content);
-          } else {
-            $xeTooltip.close();
+      handleDelayFn();
+      (0, import_vue.onMounted)(() => {
+        const $scrollbar = contentScrollbar.value;
+        if ($scrollbar) {
+          const viewEl = $scrollbar.getScrollViewElem();
+          if (viewEl) {
+            viewEl.addEventListener("wheel", wheelEvent, { passive: false });
+            internalData.scrollbarViewEl = viewEl;
           }
         }
-        reactData.isUpdate = false;
-      }
-    );
-    handleDelayFn();
-    (0, import_vue.onMounted)(() => {
-      const $scrollbar = contentScrollbar.value;
-      if ($scrollbar) {
-        const viewEl = $scrollbar.getScrollViewElem();
-        if (viewEl) {
-          viewEl.addEventListener("wheel", wheelEvent, { passive: false });
-          internalData.scrollbarViewEl = viewEl;
+        const contentWrapperfEl = contentWrapperElem.value;
+        if (contentWrapperfEl) {
+          contentWrapperfEl.addEventListener("wheel", wheelEvent, { passive: false });
         }
-      }
-      const contentWrapperfEl = contentWrapperElem.value;
-      if (contentWrapperfEl) {
-        contentWrapperfEl.addEventListener("wheel", wheelEvent, { passive: false });
-      }
-      (0, import_vue.nextTick)(() => {
-        const { trigger, content } = props;
+        (0, import_vue.nextTick)(() => {
+          const { trigger, content } = props;
+          const panelElem = refElem.value;
+          if (panelElem) {
+            const parentNode = panelElem.parentNode;
+            if (parentNode) {
+              reactData.tipContent = content;
+              reactData.tipZindex = (0, import_utils.nextZIndex)();
+              import_xe_utils.default.arrayEach(panelElem.children, (elem, index) => {
+                if (index) {
+                  parentNode.insertBefore(elem, panelElem);
+                  if (!reactData.target) {
+                    reactData.target = elem;
+                  }
+                }
+              });
+              parentNode.removeChild(panelElem);
+              const { target } = reactData;
+              if (target) {
+                if (trigger === "hover") {
+                  target.onmouseenter = targetMouseenterEvent;
+                  target.onmouseleave = targetMouseleaveEvent;
+                } else if (trigger === "click") {
+                  target.onclick = clickEvent;
+                }
+              }
+              if (props.modelValue) {
+                handleVisible(target || getSelectorEl(), content);
+              }
+            }
+          }
+        });
+        globalEvents.on($xeTooltip, "blur", handleGlobalBlurEvent);
+        globalEvents.on($xeTooltip, "scroll", handleGlobalScrollEvent);
+      });
+      (0, import_vue.onBeforeUnmount)(() => {
+        const { target } = reactData;
+        const { scrollbarViewEl } = internalData;
         const panelElem = refElem.value;
+        if (target) {
+          target.onmouseenter = null;
+          target.onmouseleave = null;
+          target.onclick = null;
+        }
+        const contentWrapperfEl = contentWrapperElem.value;
+        if (contentWrapperfEl) {
+          contentWrapperfEl.removeEventListener("wheel", wheelEvent);
+        }
+        if (scrollbarViewEl) {
+          scrollbarViewEl.removeEventListener("wheel", wheelEvent);
+        }
         if (panelElem) {
           const parentNode = panelElem.parentNode;
           if (parentNode) {
-            reactData.tipContent = content;
-            reactData.tipZindex = (0, import_utils.nextZIndex)();
-            import_xe_utils.default.arrayEach(panelElem.children, (elem, index) => {
-              if (index) {
-                parentNode.insertBefore(elem, panelElem);
-                if (!reactData.target) {
-                  reactData.target = elem;
-                }
-              }
-            });
             parentNode.removeChild(panelElem);
-            const { target } = reactData;
-            if (target) {
-              if (trigger === "hover") {
-                target.onmouseenter = targetMouseenterEvent;
-                target.onmouseleave = targetMouseleaveEvent;
-              } else if (trigger === "click") {
-                target.onclick = clickEvent;
-              }
-            }
-            if (props.modelValue) {
-              handleVisible(target || getSelectorEl(), content);
-            }
           }
         }
+        globalEvents.off($xeTooltip, "blur");
+        globalEvents.off($xeTooltip, "scroll");
+        import_xe_utils.default.assign(reactData, createReactData());
+        import_xe_utils.default.assign(internalData, createInternalData());
       });
-      globalEvents.on($xeTooltip, "blur", handleGlobalBlurEvent);
-      globalEvents.on($xeTooltip, "scroll", handleGlobalScrollEvent);
-    });
-    (0, import_vue.onBeforeUnmount)(() => {
-      const { target } = reactData;
-      const { scrollbarViewEl } = internalData;
-      const panelElem = refElem.value;
-      if (target) {
-        target.onmouseenter = null;
-        target.onmouseleave = null;
-        target.onclick = null;
-      }
-      const contentWrapperfEl = contentWrapperElem.value;
-      if (contentWrapperfEl) {
-        contentWrapperfEl.removeEventListener("wheel", wheelEvent);
-      }
-      if (scrollbarViewEl) {
-        scrollbarViewEl.removeEventListener("wheel", wheelEvent);
-      }
-      if (panelElem) {
-        const parentNode = panelElem.parentNode;
-        if (parentNode) {
-          parentNode.removeChild(panelElem);
-        }
-      }
-      globalEvents.off($xeTooltip, "blur");
-      globalEvents.off($xeTooltip, "scroll");
-      import_xe_utils.default.assign(reactData, createReactData());
-      import_xe_utils.default.assign(internalData, createInternalData());
-    });
-    $xeTooltip.renderVN = renderVN;
-    return $xeTooltip;
-  },
-  render() {
-    return this.renderVN();
-  }
-});
+      $xeTooltip.renderVN = renderVN;
+      return $xeTooltip;
+    },
+    render() {
+      return this.renderVN();
+    }
+  })
+);