vft 0.0.373 → 0.0.375

package/es/components/tooltip/tooltip.vue2.js

@@ -1,29 +1,32 @@
-import { defineComponent as T, ref as a, getCurrentInstance as $, toRef as l, computed as h, provide as H, readonly as L, unref as p, watch as V, onDeactivated as z, createBlock as w, openBlock as s, withCtx as c, createVNode as v, renderSlot as B, createCommentVNode as C, createElementBlock as k, toDisplayString as D } from "vue";
-import { VftPopper as K } from "../popper/index.js";
+import { defineComponent, ref, getCurrentInstance, toRef, computed, provide, readonly, unref, watch, onDeactivated, createBlock, openBlock, withCtx, createVNode, renderSlot, createCommentVNode, createElementBlock, toDisplayString } from "vue";
+import { VftPopper } from "../popper/index.js";
 import "@vueuse/core";
-import { isBoolean as F } from "@vft/utils";
+import { isBoolean } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useId as j } from "../../hooks/use-id/index.js";
-import { useNamespace as J } from "../../hooks/use-namespace/index.js";
+import { useId } from "../../hooks/use-id/index.js";
+import { useNamespace } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
-import { usePopperContainer as U } from "../../hooks/use-popper-container/index.js";
+import { usePopperContainer } from "../../hooks/use-popper-container/index.js";
 import "../../hooks/use-z-index/index.js";
-import { useDelayedToggle as Y } from "../../hooks/use-delayed-toggle/index.js";
-import { EVENT_CODE as y } from "@vft/constants";
-import { TOOLTIP_INJECTION_KEY as q } from "./constants.js";
-import G from "./content.vue2.js";
-import Q from "./trigger.vue2.js";
-import { useTooltipModelToggle as W } from "./utils.js";
-import X from "../popper/arrow.vue2.js";
-const Z = ["innerHTML"], _ = { key: 1 }, x = T({
+import { useDelayedToggle } from "../../hooks/use-delayed-toggle/index.js";
+import { EVENT_CODE } from "@vft/constants";
+import { TOOLTIP_INJECTION_KEY } from "./constants.js";
+import _sfc_main$2 from "./content.vue2.js";
+import _sfc_main$1 from "./trigger.vue2.js";
+import { useTooltipModelToggle } from "./utils.js";
+import _sfc_main$3 from "../popper/arrow.vue2.js";
+const _hoisted_1 = ["innerHTML"];
+const _hoisted_2 = { key: 1 };
+const __default__ = defineComponent({
   name: "VftTooltip"
-}), ve = /* @__PURE__ */ T({
-  ...x,
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
   props: {
     role: { default: "tooltip" },
-    showArrow: { type: Boolean, default: !0 },
+    showArrow: { type: Boolean, default: true },
     arrowOffset: { default: 5 },
     virtualRef: {},
     virtualTriggering: { type: Boolean },
@@ -38,7 +41,7 @@ const Z = ["innerHTML"], _ = { key: 1 }, x = T({
     open: { type: Boolean },
     boundariesPadding: { default: 0 },
     fallbackPlacements: {},
-    gpuAcceleration: { type: Boolean, default: !0 },
+    gpuAcceleration: { type: Boolean, default: true },
     offset: { default: 12 },
     placement: { default: "bottom" },
     popperOptions: { default: () => ({}) },
@@ -47,28 +50,28 @@ const Z = ["innerHTML"], _ = { key: 1 }, x = T({
     className: {},
     effect: { default: "dark" },
     visible: { type: Boolean, default: null },
-    enterable: { type: Boolean, default: !0 },
+    enterable: { type: Boolean, default: true },
     pure: { type: Boolean },
-    focusOnShow: { type: Boolean, default: !1 },
-    trapping: { type: Boolean, default: !1 },
+    focusOnShow: { type: Boolean, default: false },
+    trapping: { type: Boolean, default: false },
     popperClass: {},
     popperStyle: { type: [Boolean, null, String, Object, Array] },
     referenceEl: {},
     triggerTargetEl: {},
-    stopPopperMouseEvent: { type: Boolean, default: !0 },
+    stopPopperMouseEvent: { type: Boolean, default: true },
     ariaLabel: {},
     zIndex: {},
     showAfter: { default: 0 },
     hideAfter: { default: 200 },
     appendTo: {},
     content: { default: "" },
-    rawContent: { type: Boolean, default: !1 },
+    rawContent: { type: Boolean, default: false },
     persistent: { type: Boolean },
     transition: {},
-    teleported: { type: Boolean, default: !0 },
+    teleported: { type: Boolean, default: true },
     disabled: { type: Boolean },
     trigger: { default: "hover" },
-    triggerKeys: { default: () => [y.enter, y.numpadEnter, y.space] }
+    triggerKeys: { default: () => [EVENT_CODE.enter, EVENT_CODE.numpadEnter, EVENT_CODE.space] }
   },
   emits: [
     "before-show",
@@ -78,155 +81,183 @@ const Z = ["innerHTML"], _ = { key: 1 }, x = T({
     "open",
     "close"
   ],
-  setup(i, { expose: A, emit: O }) {
-    const r = O;
-    U();
-    const E = J("tooltip"), I = j(), f = a(), d = a(), b = () => {
-      const e = p(f);
-      e && e.popperInstanceRef?.update();
-    }, o = a(!1), t = a(), { show: P, hide: u, hasUpdateHandler: R } = W({
-      indicator: o,
-      toggleReason: t
-    }), n = $(), { onOpen: g, onClose: m } = Y({
-      showAfter: l(n.props, "showAfter"),
-      hideAfter: l(n.props, "hideAfter"),
-      autoClose: l(n.props, "autoClose"),
-      open: P,
-      close: u
-    }), S = h(
-      () => F(i.visible) && !R.value
-    ), N = h(() => [E.b(), i.popperClass]);
-    H(q, {
-      controlled: S,
-      id: I,
-      open: L(o),
-      trigger: l(n.props, "trigger"),
-      onOpen: (e) => {
-        g(e);
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const emit = __emit;
+    usePopperContainer();
+    const ns = useNamespace("tooltip");
+    const id = useId();
+    const popperRef = ref();
+    const contentRef = ref();
+    const updatePopper = () => {
+      const popperComponent = unref(popperRef);
+      if (popperComponent) {
+        popperComponent.popperInstanceRef?.update();
+      }
+    };
+    const open = ref(false);
+    const toggleReason = ref();
+    const { show, hide, hasUpdateHandler } = useTooltipModelToggle({
+      indicator: open,
+      toggleReason
+    });
+    const instance = getCurrentInstance();
+    const { onOpen, onClose } = useDelayedToggle({
+      showAfter: toRef(instance.props, "showAfter"),
+      hideAfter: toRef(instance.props, "hideAfter"),
+      autoClose: toRef(instance.props, "autoClose"),
+      open: show,
+      close: hide
+    });
+    const controlled = computed(
+      () => isBoolean(__props.visible) && !hasUpdateHandler.value
+    );
+    const kls = computed(() => {
+      return [ns.b(), __props.popperClass];
+    });
+    provide(TOOLTIP_INJECTION_KEY, {
+      controlled,
+      id,
+      open: readonly(open),
+      trigger: toRef(instance.props, "trigger"),
+      onOpen: (event) => {
+        onOpen(event);
       },
-      onClose: (e) => {
-        m(e);
+      onClose: (event) => {
+        onClose(event);
       },
-      onToggle: (e) => {
-        p(o) ? m(e) : g(e);
+      onToggle: (event) => {
+        if (unref(open)) {
+          onClose(event);
+        } else {
+          onOpen(event);
+        }
       },
       onShow: () => {
-        r("show", t.value);
+        emit("show", toggleReason.value);
       },
       onHide: () => {
-        r("hide", t.value);
+        emit("hide", toggleReason.value);
       },
       onBeforeShow: () => {
-        r("before-show", t.value);
+        emit("before-show", toggleReason.value);
       },
       onBeforeHide: () => {
-        r("before-hide", t.value);
+        emit("before-hide", toggleReason.value);
       },
-      updatePopper: b
-    }), V(
-      () => i.disabled,
-      (e) => {
-        e && o.value && (o.value = !1);
+      updatePopper
+    });
+    watch(
+      () => __props.disabled,
+      (disabled) => {
+        if (disabled && open.value) {
+          open.value = false;
+        }
       }
     );
-    const M = (e) => d.value?.isFocusInsideContent(e);
-    return z(() => o.value && u()), A({
+    const isFocusInsideContent = (event) => {
+      return contentRef.value?.isFocusInsideContent(event);
+    };
+    onDeactivated(() => open.value && hide());
+    __expose({
       /**
        * @description el-popper component instance
        */
-      popperRef: f,
+      popperRef,
       /**
        * @description el-tooltip-content component instance
        */
-      contentRef: d,
+      contentRef,
       /**
        * @description validate current focus event is trigger inside el-tooltip-content
        */
-      isFocusInsideContent: M,
+      isFocusInsideContent,
       /**
        * @description update el-popper component instance
        */
-      updatePopper: b,
+      updatePopper,
       /**
        * @description expose onOpen function to mange el-tooltip open state
        */
-      onOpen: g,
+      onOpen,
       /**
        * @description expose onOpen function to mange el-tooltip open state
        */
-      onClose: m,
+      onClose,
       /**
        * @description expose hide function
        */
-      hide: u
-    }), (e, ee) => (s(), w(p(K), {
-      ref_key: "popperRef",
-      ref: f,
-      role: e.role
-    }, {
-      default: c(() => [
-        v(Q, {
-          disabled: e.disabled,
-          trigger: e.trigger,
-          "trigger-keys": e.triggerKeys,
-          "virtual-ref": e.virtualRef,
-          "virtual-triggering": e.virtualTriggering
-        }, {
-          default: c(() => [
-            e.$slots.default ? B(e.$slots, "default", { key: 0 }) : C("", !0)
-          ]),
-          _: 3
-        }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
-        v(G, {
-          ref_key: "contentRef",
-          ref: d,
-          "aria-label": e.ariaLabel,
-          "boundaries-padding": e.boundariesPadding,
-          content: e.content,
-          disabled: e.disabled,
-          effect: e.effect,
-          enterable: e.enterable,
-          "fallback-placements": e.fallbackPlacements,
-          "hide-after": e.hideAfter,
-          "gpu-acceleration": e.gpuAcceleration,
-          offset: e.offset,
-          persistent: e.persistent,
-          "popper-class": N.value,
-          "popper-style": e.popperStyle,
-          placement: e.placement,
-          "popper-options": e.popperOptions,
-          "arrow-offset": e.arrowOffset,
-          pure: e.pure,
-          "raw-content": e.rawContent,
-          "reference-el": e.referenceEl,
-          "trigger-target-el": e.triggerTargetEl,
-          "show-after": e.showAfter,
-          strategy: e.strategy,
-          teleported: e.teleported,
-          transition: e.transition,
-          "virtual-triggering": e.virtualTriggering,
-          "z-index": e.zIndex,
-          "append-to": e.appendTo
-        }, {
-          default: c(() => [
-            B(e.$slots, "content", {}, () => [
-              e.rawContent ? (s(), k("span", {
+      hide
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(VftPopper), {
+        ref_key: "popperRef",
+        ref: popperRef,
+        role: _ctx.role
+      }, {
+        default: withCtx(() => [
+          createVNode(_sfc_main$1, {
+            disabled: _ctx.disabled,
+            trigger: _ctx.trigger,
+            "trigger-keys": _ctx.triggerKeys,
+            "virtual-ref": _ctx.virtualRef,
+            "virtual-triggering": _ctx.virtualTriggering
+          }, {
+            default: withCtx(() => [
+              _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("", true)
+            ]),
+            _: 3
+          }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
+          createVNode(_sfc_main$2, {
+            ref_key: "contentRef",
+            ref: contentRef,
+            "aria-label": _ctx.ariaLabel,
+            "boundaries-padding": _ctx.boundariesPadding,
+            content: _ctx.content,
+            disabled: _ctx.disabled,
+            effect: _ctx.effect,
+            enterable: _ctx.enterable,
+            "fallback-placements": _ctx.fallbackPlacements,
+            "hide-after": _ctx.hideAfter,
+            "gpu-acceleration": _ctx.gpuAcceleration,
+            offset: _ctx.offset,
+            persistent: _ctx.persistent,
+            "popper-class": kls.value,
+            "popper-style": _ctx.popperStyle,
+            placement: _ctx.placement,
+            "popper-options": _ctx.popperOptions,
+            "arrow-offset": _ctx.arrowOffset,
+            pure: _ctx.pure,
+            "raw-content": _ctx.rawContent,
+            "reference-el": _ctx.referenceEl,
+            "trigger-target-el": _ctx.triggerTargetEl,
+            "show-after": _ctx.showAfter,
+            strategy: _ctx.strategy,
+            teleported: _ctx.teleported,
+            transition: _ctx.transition,
+            "virtual-triggering": _ctx.virtualTriggering,
+            "z-index": _ctx.zIndex,
+            "append-to": _ctx.appendTo
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "content", {}, () => [
+                _ctx.rawContent ? (openBlock(), createElementBlock("span", {
+                  key: 0,
+                  innerHTML: _ctx.content
+                }, null, 8, _hoisted_1)) : (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(_ctx.content), 1))
+              ]),
+              _ctx.showArrow ? (openBlock(), createBlock(unref(_sfc_main$3), {
                 key: 0,
-                innerHTML: e.content
-              }, null, 8, Z)) : (s(), k("span", _, D(e.content), 1))
+                "arrow-offset": _ctx.arrowOffset
+              }, null, 8, ["arrow-offset"])) : createCommentVNode("", true)
             ]),
-            e.showArrow ? (s(), w(p(X), {
-              key: 0,
-              "arrow-offset": e.arrowOffset
-            }, null, 8, ["arrow-offset"])) : C("", !0)
-          ]),
-          _: 3
-        }, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "arrow-offset", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to"])
-      ]),
-      _: 3
-    }, 8, ["role"]));
+            _: 3
+          }, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "arrow-offset", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to"])
+        ]),
+        _: 3
+      }, 8, ["role"]);
+    };
   }
 });
 export {
-  ve as default
+  _sfc_main as default
 };

package/es/components/tooltip/trigger.vue.js

@@ -1,4 +1,4 @@
-import f from "./trigger.vue2.js";
+import _sfc_main from "./trigger.vue2.js";
 export {
-  f as default
+  _sfc_main as default
 };

package/es/components/tooltip/trigger.vue2.js

@@ -1,91 +1,112 @@
-import { defineComponent as a, inject as K, ref as O, createBlock as w, openBlock as x, unref as o, normalizeClass as b, withCtx as D, renderSlot as N } from "vue";
-import { EVENT_CODE as c } from "@vft/constants";
+import { defineComponent, inject, ref, createBlock, openBlock, unref, normalizeClass, withCtx, renderSlot } from "vue";
+import { EVENT_CODE } from "@vft/constants";
 import "../popper/index.js";
 import "@vueuse/core";
 import "@vft/utils";
-import { composeEventHandlers as n } from "../../utils/event.js";
+import { composeEventHandlers } from "../../utils/event.js";
 import "../config-provider/hooks/use-global-config.js";
 import "lodash-es";
-import { useNamespace as F } from "../../hooks/use-namespace/index.js";
+import { useNamespace } from "../../hooks/use-namespace/index.js";
 import "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-import { TOOLTIP_INJECTION_KEY as I } from "./constants.js";
-import { whenTrigger as i } from "./utils.js";
-import R from "../popper/trigger.vue2.js";
-const V = a({
+import { TOOLTIP_INJECTION_KEY } from "./constants.js";
+import { whenTrigger } from "./utils.js";
+import _sfc_main$1 from "../popper/trigger.vue2.js";
+const __default__ = defineComponent({
   name: "VftTooltipTrigger"
-}), X = /* @__PURE__ */ a({
-  ...V,
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
   props: {
     disabled: { type: Boolean },
     trigger: { default: "hover" },
-    triggerKeys: { default: () => [c.enter, c.space] },
+    triggerKeys: { default: () => [EVENT_CODE.enter, EVENT_CODE.space] },
     virtualRef: {},
     virtualTriggering: { type: Boolean }
   },
-  setup(t, { expose: m }) {
-    const f = F("tooltip"), { controlled: d, id: p, open: v, onOpen: s, onClose: u, onToggle: l } = K(
-      I,
+  setup(__props, { expose: __expose }) {
+    const ns = useNamespace("tooltip");
+    const { controlled, id, open, onOpen, onClose, onToggle } = inject(
+      TOOLTIP_INJECTION_KEY,
       void 0
-    ), C = O(null), r = () => {
-      if (o(d) || t.disabled)
-        return !0;
-    }, T = n(
-      r,
-      i(t.trigger, "hover", s)
-    ), h = n(
-      r,
-      i(t.trigger, "hover", u)
-    ), y = n(
-      r,
-      i(t.trigger, "click", (e) => {
-        e.button === 0 && l(e);
+    );
+    const triggerRef = ref(null);
+    const stopWhenControlledOrDisabled = () => {
+      if (unref(controlled) || __props.disabled) {
+        return true;
+      }
+    };
+    const onMouseenter = composeEventHandlers(
+      stopWhenControlledOrDisabled,
+      whenTrigger(__props.trigger, "hover", onOpen)
+    );
+    const onMouseleave = composeEventHandlers(
+      stopWhenControlledOrDisabled,
+      whenTrigger(__props.trigger, "hover", onClose)
+    );
+    const onClick = composeEventHandlers(
+      stopWhenControlledOrDisabled,
+      whenTrigger(__props.trigger, "click", (e) => {
+        if (e.button === 0) {
+          onToggle(e);
+        }
       })
-    ), B = n(
-      r,
-      i(t.trigger, "focus", s)
-    ), M = n(
-      r,
-      i(t.trigger, "focus", u)
-    ), k = n(
-      r,
-      i(t.trigger, "contextmenu", (e) => {
-        e.preventDefault(), l(e);
+    );
+    const onFocus = composeEventHandlers(
+      stopWhenControlledOrDisabled,
+      whenTrigger(__props.trigger, "focus", onOpen)
+    );
+    const onBlur = composeEventHandlers(
+      stopWhenControlledOrDisabled,
+      whenTrigger(__props.trigger, "focus", onClose)
+    );
+    const onContextMenu = composeEventHandlers(
+      stopWhenControlledOrDisabled,
+      whenTrigger(__props.trigger, "contextmenu", (e) => {
+        e.preventDefault();
+        onToggle(e);
       })
-    ), E = n(
-      r,
+    );
+    const onKeydown = composeEventHandlers(
+      stopWhenControlledOrDisabled,
       (e) => {
-        const { code: g } = e;
-        t.triggerKeys.includes(g) && (e.preventDefault(), l(e));
+        const { code } = e;
+        if (__props.triggerKeys.includes(code)) {
+          e.preventDefault();
+          onToggle(e);
+        }
       }
     );
-    return m({
+    __expose({
       /**
        * @description trigger element
        */
-      triggerRef: C
-    }), (e, g) => (x(), w(o(R), {
-      id: o(p),
-      "virtual-ref": e.virtualRef,
-      open: o(v),
-      "virtual-triggering": e.virtualTriggering,
-      class: b(o(f).e("trigger")),
-      onBlur: o(M),
-      onClick: o(y),
-      onContextmenu: o(k),
-      onFocus: o(B),
-      onMouseenter: o(T),
-      onMouseleave: o(h),
-      onKeydown: o(E)
-    }, {
-      default: D(() => [
-        N(e.$slots, "default")
-      ]),
-      _: 3
-    }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]));
+      triggerRef
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), {
+        id: unref(id),
+        "virtual-ref": _ctx.virtualRef,
+        open: unref(open),
+        "virtual-triggering": _ctx.virtualTriggering,
+        class: normalizeClass(unref(ns).e("trigger")),
+        onBlur: unref(onBlur),
+        onClick: unref(onClick),
+        onContextmenu: unref(onContextMenu),
+        onFocus: unref(onFocus),
+        onMouseenter: unref(onMouseenter),
+        onMouseleave: unref(onMouseleave),
+        onKeydown: unref(onKeydown)
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]);
+    };
   }
 });
 export {
-  X as default
+  _sfc_main as default
 };

package/es/components/tooltip/utils.js

@@ -1,16 +1,25 @@
 import "@vueuse/core";
-import { isArray as t } from "@vft/utils";
+import { isArray } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
-import { unref as m } from "vue";
+import { unref } from "vue";
 import "lodash-es";
-import { createModelToggleComposable as p } from "../../hooks/use-model-toggle/index.js";
+import { createModelToggleComposable } from "../../hooks/use-model-toggle/index.js";
 import "@popperjs/core";
 import "../../hooks/use-z-index/index.js";
-const l = (o, r) => t(o) ? o.includes(r) : o === r, a = (o, r, e) => (i) => {
-  l(m(o), r) && e(i);
-}, { useModelToggle: M } = p("visible");
+const isTriggerType = (trigger, type) => {
+  if (isArray(trigger)) {
+    return trigger.includes(type);
+  }
+  return trigger === type;
+};
+const whenTrigger = (trigger, type, handler) => {
+  return (e) => {
+    isTriggerType(unref(trigger), type) && handler(e);
+  };
+};
+const { useModelToggle: useTooltipModelToggle } = createModelToggleComposable("visible");
 export {
-  l as isTriggerType,
-  M as useTooltipModelToggle,
-  a as whenTrigger
+  isTriggerType,
+  useTooltipModelToggle,
+  whenTrigger
 };

package/es/components/transfer/composables/index.js

@@ -1,12 +1,12 @@
-import { useCheck as r } from "./use-check.js";
-import { useCheckedChange as s } from "./use-checked-change.js";
-import { useComputedData as m } from "./use-computed-data.js";
-import { useMove as f } from "./use-move.js";
-import { usePropsAlias as a } from "./use-props-alias.js";
+import { useCheck } from "./use-check.js";
+import { useCheckedChange } from "./use-checked-change.js";
+import { useComputedData } from "./use-computed-data.js";
+import { useMove } from "./use-move.js";
+import { usePropsAlias } from "./use-props-alias.js";
 export {
-  r as useCheck,
-  s as useCheckedChange,
-  m as useComputedData,
-  f as useMove,
-  a as usePropsAlias
+  useCheck,
+  useCheckedChange,
+  useComputedData,
+  useMove,
+  usePropsAlias
 };