vft 0.0.89 → 0.0.91

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

@@ -1,65 +1,65 @@
-import { defineComponent as k, ref as r, computed as P, provide as I, readonly as S, unref as i, watch as M, onDeactivated as N, openBlock as f, createBlock as h, withCtx as g, createVNode as b, renderSlot as w, createCommentVNode as v, createElementBlock as B, toDisplayString as $ } from "vue";
+import { defineComponent as k, ref as l, computed as I, provide as S, readonly as M, unref as p, watch as N, onDeactivated as $, openBlock as i, createBlock as h, withCtx as m, createVNode as b, renderSlot as w, createCommentVNode as v, createElementBlock as B, toDisplayString as H } from "vue";
 import { EVENT_CODE as C } from "@vft/constants";
-import { VftPopper as x } from "../popper/index.js";
-import { isBoolean as H } from "@vft/utils";
+import { VftPopper as L } from "../popper/index.js";
+import { isBoolean as z } from "@vft/utils";
 import "../config-provider/hooks/use-global-config.js";
 import "@popperjs/core";
 import "lodash";
 import "../../hooks/use-z-index/index.js";
-import { useId as L } from "../../hooks/use-id/index.js";
-import { usePopperContainer as z } from "../../hooks/use-popper-container/index.js";
-import { useDelayedToggle as D } from "../../hooks/use-delayed-toggle/index.js";
+import { useId as D } from "../../hooks/use-id/index.js";
+import { usePopperContainer as K } from "../../hooks/use-popper-container/index.js";
+import { useDelayedToggle as V } from "../../hooks/use-delayed-toggle/index.js";
 import "@vueuse/core";
 import "../../utils/ns-cover.js";
-import { TOOLTIP_INJECTION_KEY as K } from "./constants.js";
-import V from "./trigger.vue2.js";
-import J from "./content.vue2.js";
-import { useTooltipModelToggle as U } from "./utils.js";
-import Y from "../popper/arrow.vue2.js";
-const j = ["innerHTML"], q = { key: 1 }, G = k({
+import { TOOLTIP_INJECTION_KEY as F } from "./constants.js";
+import J from "./trigger.vue2.js";
+import U from "./content.vue2.js";
+import { useTooltipModelToggle as Y } from "./utils.js";
+import j from "../popper/arrow.vue2.js";
+const q = ["innerHTML"], G = { key: 1 }, Q = k({
   name: "vft-tooltip"
-}), pe = /* @__PURE__ */ k({
-  ...G,
+}), ge = /* @__PURE__ */ k({
+  ...Q,
   props: {
     role: { default: "tooltip" },
     showArrow: { type: Boolean, default: !0 },
     arrowOffset: { default: 5 },
-    virtualRef: null,
+    virtualRef: {},
     virtualTriggering: { type: Boolean },
-    onMouseenter: { type: Function },
-    onMouseleave: { type: Function },
-    onClick: { type: Function },
-    onKeydown: { type: Function },
-    onFocus: { type: Function },
-    onBlur: { type: Function },
-    onContextmenu: { type: Function },
-    id: null,
+    onMouseenter: {},
+    onMouseleave: {},
+    onClick: {},
+    onKeydown: {},
+    onFocus: {},
+    onBlur: {},
+    onContextmenu: {},
+    id: {},
     open: { type: Boolean },
     boundariesPadding: { default: 0 },
-    fallbackPlacements: null,
+    fallbackPlacements: {},
     gpuAcceleration: { type: Boolean, default: !0 },
     offset: { default: 12 },
     placement: { default: "bottom" },
     popperOptions: { default: {} },
     strategy: { default: "absolute" },
-    style: null,
-    className: null,
+    style: {},
+    className: {},
     effect: { default: "dark" },
     visible: { type: Boolean, default: null },
     enterable: { type: Boolean, default: !0 },
     pure: { type: Boolean },
     focusOnShow: { type: Boolean, default: !1 },
     trapping: { type: Boolean, default: !1 },
-    popperClass: null,
-    popperStyle: null,
-    referenceEl: null,
-    triggerTargetEl: null,
+    popperClass: {},
+    popperStyle: {},
+    referenceEl: {},
+    triggerTargetEl: {},
     stopPopperMouseEvent: { type: Boolean, default: !0 },
-    ariaLabel: null,
-    zIndex: null,
+    ariaLabel: {},
+    zIndex: {},
     showAfter: { default: 0 },
     hideAfter: { default: 200 },
-    appendTo: null,
+    appendTo: {},
     content: { default: "" },
     rawContent: { type: Boolean, default: !1 },
     persistent: { type: Boolean },
@@ -70,109 +70,109 @@ const j = ["innerHTML"], q = { key: 1 }, G = k({
     triggerKeys: { default: [C.enter, C.space] }
   },
   emits: ["before-show", "before-hide", "show", "hide", "open", "close"],
-  setup(e, { expose: T, emit: a }) {
-    z();
-    const A = L(), u = r(), d = r(), m = () => {
-      var o;
-      const t = i(u);
-      t && ((o = t.popperInstanceRef) == null || o.update());
-    }, n = r(!1), l = r(), { show: E, hide: s, hasUpdateHandler: O } = U({
-      indicator: n,
-      toggleReason: l
-    }), { onOpen: c, onClose: p } = D({
-      showAfter: e.showAfter,
-      hideAfter: e.hideAfter,
+  setup(r, { expose: T, emit: a }) {
+    K();
+    const A = D(), s = l(), f = l(), c = () => {
+      var t;
+      const e = p(s);
+      e && ((t = e.popperInstanceRef) == null || t.update());
+    }, o = l(!1), n = l(), { show: E, hide: d, hasUpdateHandler: O } = Y({
+      indicator: o,
+      toggleReason: n
+    }), { onOpen: u, onClose: g } = V({
+      showAfter: r.showAfter,
+      hideAfter: r.hideAfter,
       open: E,
-      close: s
-    }), R = P(() => H(e.visible) && !O.value);
-    I(K, {
+      close: d
+    }), R = I(() => z(r.visible) && !O.value);
+    S(F, {
       controlled: R,
       id: A,
-      open: S(n),
-      trigger: e.trigger,
-      onOpen: (t) => {
-        c(t);
+      open: M(o),
+      trigger: r.trigger,
+      onOpen: (e) => {
+        u(e);
       },
-      onClose: (t) => {
-        p(t);
+      onClose: (e) => {
+        g(e);
       },
-      onToggle: (t) => {
-        i(n) ? p(t) : c(t);
+      onToggle: (e) => {
+        p(o) ? g(e) : u(e);
       },
       onShow: () => {
-        a("show", l.value);
+        a("show", n.value);
       },
       onHide: () => {
-        a("hide", l.value);
+        a("hide", n.value);
       },
       onBeforeShow: () => {
-        a("before-show", l.value);
+        a("before-show", n.value);
       },
       onBeforeHide: () => {
-        a("before-hide", l.value);
+        a("before-hide", n.value);
       },
-      updatePopper: m
-    }), M(
-      () => e.disabled,
-      (t) => {
-        t && n.value && (n.value = !1);
+      updatePopper: c
+    }), N(
+      () => r.disabled,
+      (e) => {
+        e && o.value && (o.value = !1);
       }
     );
-    const F = () => {
-      var o, y;
-      const t = (y = (o = d.value) == null ? void 0 : o.contentRef) == null ? void 0 : y.popperContentRef;
-      return t && t.contains(document.activeElement);
+    const P = () => {
+      var t, y;
+      const e = (y = (t = f.value) == null ? void 0 : t.contentRef) == null ? void 0 : y.popperContentRef;
+      return e && e.contains(document.activeElement);
     };
-    return N(() => n.value && s()), T({
+    return $(() => o.value && d()), T({
       /**
        * @description el-popper component instance
        */
-      popperRef: u,
+      popperRef: s,
       /**
        * @description el-tooltip-content component instance
        */
-      contentRef: d,
+      contentRef: f,
       /**
        * @description validate current focus event is trigger inside el-tooltip-content
        */
-      isFocusInsideContent: F,
+      isFocusInsideContent: P,
       /**
        * @description update el-popper component instance
        */
-      updatePopper: m,
+      updatePopper: c,
       /**
        * @description expose onOpen function to mange el-tooltip open state
        */
-      onOpen: c,
+      onOpen: u,
       /**
        * @description expose onOpen function to mange el-tooltip open state
        */
-      onClose: p,
+      onClose: g,
       /**
        * @description expose hide function
        */
-      hide: s
-    }), (t, o) => (f(), h(i(x), {
+      hide: d
+    }), (e, t) => (i(), h(p(L), {
       ref_key: "popperRef",
-      ref: u,
+      ref: s,
       role: e.role
     }, {
-      default: g(() => [
-        b(V, {
+      default: m(() => [
+        b(J, {
           disabled: e.disabled,
           trigger: e.trigger,
           "trigger-keys": e.triggerKeys,
           "virtual-ref": e.virtualRef,
           "virtual-triggering": e.virtualTriggering
         }, {
-          default: g(() => [
-            t.$slots.default ? w(t.$slots, "default", { key: 0 }) : v("", !0)
+          default: m(() => [
+            e.$slots.default ? w(e.$slots, "default", { key: 0 }) : v("", !0)
           ]),
           _: 3
         }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
-        b(J, {
+        b(U, {
           ref_key: "contentRef",
-          ref: d,
+          ref: f,
           "aria-label": e.ariaLabel,
           "boundaries-padding": e.boundariesPadding,
           content: e.content,
@@ -200,14 +200,14 @@ const j = ["innerHTML"], q = { key: 1 }, G = k({
           "z-index": e.zIndex,
           "append-to": e.appendTo
         }, {
-          default: g(() => [
-            w(t.$slots, "content", {}, () => [
-              e.rawContent ? (f(), B("span", {
+          default: m(() => [
+            w(e.$slots, "content", {}, () => [
+              e.rawContent ? (i(), B("span", {
                 key: 0,
                 innerHTML: e.content
-              }, null, 8, j)) : (f(), B("span", q, $(e.content), 1))
+              }, null, 8, q)) : (i(), B("span", G, H(e.content), 1))
             ]),
-            e.showArrow ? (f(), h(i(Y), {
+            e.showArrow ? (i(), h(p(j), {
               key: 0,
               "arrow-offset": e.arrowOffset
             }, null, 8, ["arrow-offset"])) : v("", !0)
@@ -220,5 +220,5 @@ const j = ["innerHTML"], q = { key: 1 }, G = k({
   }
 });
 export {
-  pe as default
+  ge as default
 };

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

@@ -1,5 +1,5 @@
-import { defineComponent as a, inject as E, ref as K, openBlock as O, createBlock as w, unref as e, normalizeClass as b, withCtx as D, renderSlot as N } from "vue";
-import { EVENT_CODE as g } from "@vft/constants";
+import { defineComponent as a, inject as K, ref as O, openBlock as w, createBlock 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 "../popper/index.js";
 import "@vft/utils";
 import "lodash";
@@ -19,44 +19,44 @@ const V = a({
   props: {
     disabled: { type: Boolean },
     trigger: { default: "hover" },
-    triggerKeys: { default: [g.enter, g.space] },
-    virtualRef: null,
+    triggerKeys: { default: [c.enter, c.space] },
+    virtualRef: {},
     virtualTriggering: { type: Boolean }
   },
   setup(t, { expose: f }) {
-    const m = F("tooltip"), { controlled: d, id: v, open: p, onOpen: u, onClose: s, onToggle: l } = E(
+    const m = F("tooltip"), { controlled: d, id: p, open: v, onOpen: s, onClose: u, onToggle: l } = K(
       I,
       void 0
-    ), C = K(null), n = () => {
-      if (e(d) || t.disabled)
+    ), C = O(null), n = () => {
+      if (o(d) || t.disabled)
         return !0;
     }, T = r(
       n,
-      i(t.trigger, "hover", u)
+      i(t.trigger, "hover", s)
     ), h = r(
       n,
-      i(t.trigger, "hover", s)
+      i(t.trigger, "hover", u)
     ), y = r(
       n,
-      i(t.trigger, "click", (o) => {
-        o.button === 0 && l(o);
+      i(t.trigger, "click", (e) => {
+        e.button === 0 && l(e);
       })
     ), B = r(
       n,
-      i(t.trigger, "focus", u)
+      i(t.trigger, "focus", s)
     ), M = r(
       n,
-      i(t.trigger, "focus", s)
+      i(t.trigger, "focus", u)
     ), k = r(
       n,
-      i(t.trigger, "contextmenu", (o) => {
-        o.preventDefault(), l(o);
+      i(t.trigger, "contextmenu", (e) => {
+        e.preventDefault(), l(e);
       })
-    ), x = r(
+    ), E = r(
       n,
-      (o) => {
-        const { code: c } = o;
-        t.triggerKeys.includes(c) && (o.preventDefault(), l(o));
+      (e) => {
+        const { code: g } = e;
+        t.triggerKeys.includes(g) && (e.preventDefault(), l(e));
       }
     );
     return f({
@@ -64,22 +64,22 @@ const V = a({
        * @description trigger element
        */
       triggerRef: C
-    }), (o, c) => (O(), w(e(R), {
-      id: e(v),
-      "virtual-ref": t.virtualRef,
-      open: e(p),
-      "virtual-triggering": t.virtualTriggering,
-      class: b(e(m).e("trigger")),
-      onBlur: e(M),
-      onClick: e(y),
-      onContextmenu: e(k),
-      onFocus: e(B),
-      onMouseenter: e(T),
-      onMouseleave: e(h),
-      onKeydown: e(x)
+    }), (e, g) => (w(), x(o(R), {
+      id: o(p),
+      "virtual-ref": e.virtualRef,
+      open: o(v),
+      "virtual-triggering": e.virtualTriggering,
+      class: b(o(m).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(o.$slots, "default")
+        N(e.$slots, "default")
       ]),
       _: 3
     }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]));

package/es/components/verify-code/verify-code.vue2.js

@@ -1,43 +1,43 @@
-import { defineComponent as m, computed as f, openBlock as a, createElementBlock as l, normalizeStyle as u, unref as o, createElementVNode as p } from "vue";
-import { useNamespace as g } from "../../hooks/use-namespace/index.js";
+import { defineComponent as n, computed as l, openBlock as p, createElementBlock as c, normalizeStyle as u, createElementVNode as g, unref as r } from "vue";
+import { useNamespace as w } from "../../hooks/use-namespace/index.js";
 import "@popperjs/core";
 import "lodash";
 import "../../hooks/use-z-index/index.js";
 import "@vueuse/core";
-import { addUnit as r } from "@vft/utils";
+import { addUnit as m } from "@vft/utils";
 import "../../utils/ns-cover.js";
-import w from "./useImageVerify.js";
-const y = ["width", "height"], k = (
+import y from "./useImageVerify.js";
+const _ = ["width", "height"], k = (
   /* hoist-static*/
-  g("verify-code")
-), C = m({
+  w("verify-code")
+), v = n({
   name: k.b()
-}), z = /* @__PURE__ */ m({
-  ...C,
+}), z = /* @__PURE__ */ n({
+  ...v,
   props: {
     height: { default: 40 },
     width: { default: 150 }
   },
-  setup(e, { expose: n }) {
-    const d = f(() => ({
-      width: r(e.width),
-      height: r(e.height)
-    })), { domRef: c, imgCode: h, getImgCode: t } = w();
-    return n({
-      getImgCode: t,
-      code: h
-    }), (v, i) => (a(), l("div", {
-      style: u(o(d))
+  setup(t, { expose: d }) {
+    const s = l(() => ({
+      width: m(t.width),
+      height: m(t.height)
+    })), { domRef: h, imgCode: a, getImgCode: e } = y();
+    return d({
+      getImgCode: e,
+      code: a
+    }), (o, i) => (p(), c("div", {
+      style: u(s.value)
     }, [
-      p("canvas", {
+      g("canvas", {
         ref_key: "domRef",
-        ref: c,
-        width: e.width,
-        height: e.height,
+        ref: h,
+        width: o.width,
+        height: o.height,
         class: "cursor-pointer",
         onClick: i[0] || (i[0] = //@ts-ignore
-        (...s) => o(t) && o(t)(...s))
-      }, null, 8, y)
+        (...f) => r(e) && r(e)(...f))
+      }, null, 8, _)
     ], 4));
   }
 });