vft 0.0.363 → 0.0.365

package/es/components/popper/composables/use-focus-trap.js

@@ -1,46 +1,26 @@
-import { ref } from "vue";
-const usePopperContentFocusTrap = (props, emit) => {
-  const trapped = ref(false);
-  const focusStartRef = ref();
-  const onFocusAfterTrapped = () => {
-    emit("focus");
-  };
-  const onFocusAfterReleased = (event) => {
-    if (event.detail?.focusReason !== "pointer") {
-      focusStartRef.value = "first";
-      emit("blur");
-    }
-  };
-  const onFocusInTrap = (event) => {
-    if (props.visible && !trapped.value) {
-      if (event.target) {
-        focusStartRef.value = event.target;
-      }
-      trapped.value = true;
-    }
-  };
-  const onFocusoutPrevented = (event) => {
-    if (!props.trapping) {
-      if (event.detail.focusReason === "pointer") {
-        event.preventDefault();
-      }
-      trapped.value = false;
-    }
-  };
-  const onReleaseRequested = () => {
-    trapped.value = false;
-    emit("close");
-  };
+import { ref as a } from "vue";
+const i = (n, s) => {
+  const o = a(!1), t = a();
   return {
-    focusStartRef,
-    trapped,
-    onFocusAfterReleased,
-    onFocusAfterTrapped,
-    onFocusInTrap,
-    onFocusoutPrevented,
-    onReleaseRequested
+    focusStartRef: t,
+    trapped: o,
+    onFocusAfterReleased: (e) => {
+      e.detail?.focusReason !== "pointer" && (t.value = "first", s("blur"));
+    },
+    onFocusAfterTrapped: () => {
+      s("focus");
+    },
+    onFocusInTrap: (e) => {
+      n.visible && !o.value && (e.target && (t.value = e.target), o.value = !0);
+    },
+    onFocusoutPrevented: (e) => {
+      n.trapping || (e.detail.focusReason === "pointer" && e.preventDefault(), o.value = !1);
+    },
+    onReleaseRequested: () => {
+      o.value = !1, s("close");
+    }
   };
 };
 export {
-  usePopperContentFocusTrap
+  i as usePopperContentFocusTrap
 };

package/es/components/popper/constants.js

@@ -1,6 +1,5 @@
-const POPPER_INJECTION_KEY = Symbol("popper");
-const POPPER_CONTENT_INJECTION_KEY = Symbol("popperContent");
+const o = Symbol("popper"), p = Symbol("popperContent");
 export {
-  POPPER_CONTENT_INJECTION_KEY,
-  POPPER_INJECTION_KEY
+  p as POPPER_CONTENT_INJECTION_KEY,
+  o as POPPER_INJECTION_KEY
 };

package/es/components/popper/content.vue.js

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

package/es/components/popper/content.vue2.js

@@ -1,21 +1,22 @@
-import { defineComponent, getCurrentInstance, inject, provide, onMounted, watch, unref, onBeforeUnmount, createElementBlock, openBlock, mergeProps, createVNode, withCtx, renderSlot } from "vue";
-import VftFocusTrap from "../focus-trap/focus-trap.vue.js";
-import { noop, isElement } from "@vft/utils";
-import { isNil } from "lodash-es";
-import { POPPER_CONTENT_INJECTION_KEY } from "./constants.js";
-import { usePopperContentFocusTrap } from "./composables/use-focus-trap.js";
-import { usePopperContent } from "./composables/use-content.js";
-import { usePopperContentDOM } from "./composables/use-content-dom.js";
-import { formItemContextKey } from "../form/constants.js";
-const __default__ = defineComponent({
+import { defineComponent as C, getCurrentInstance as D, inject as J, provide as y, onMounted as U, watch as f, unref as e, onBeforeUnmount as W, createElementBlock as Y, openBlock as Z, mergeProps as G, createVNode as H, withCtx as Q, renderSlot as X } from "vue";
+import _ from "../focus-trap/focus-trap.vue.js";
+import "../focus-trap/utils.js";
+import { noop as R, isElement as P } from "@vft/utils";
+import { isNil as ee } from "lodash-es";
+import "../form/index.js";
+import { usePopperContent as te } from "./composables/use-content.js";
+import { usePopperContentDOM as oe } from "./composables/use-content-dom.js";
+import { usePopperContentFocusTrap as re } from "./composables/use-focus-trap.js";
+import { POPPER_CONTENT_INJECTION_KEY as ae } from "./constants.js";
+import { formItemContextKey as A } from "../form/constants.js";
+const ne = C({
   name: "VftPopperContent"
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
+}), be = /* @__PURE__ */ C({
+  ...ne,
   props: {
     boundariesPadding: { default: 0 },
     fallbackPlacements: {},
-    gpuAcceleration: { type: Boolean, default: true },
+    gpuAcceleration: { type: Boolean, default: !0 },
     offset: { default: 12 },
     placement: { default: "bottom" },
     popperOptions: { default: () => ({}) },
@@ -25,15 +26,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     className: {},
     effect: { default: "dark" },
     visible: { type: Boolean },
-    enterable: { type: Boolean, default: true },
+    enterable: { type: Boolean, default: !0 },
     pure: { type: Boolean },
-    focusOnShow: { type: Boolean, default: false },
-    trapping: { type: Boolean, default: false },
+    focusOnShow: { type: Boolean, default: !1 },
+    trapping: { type: Boolean, default: !1 },
     popperClass: {},
     popperStyle: { type: [Boolean, null, String, Object, Array] },
     referenceEl: {},
     triggerTargetEl: {},
-    stopPopperMouseEvent: { type: Boolean, default: true },
+    stopPopperMouseEvent: { type: Boolean, default: !0 },
     ariaLabel: {},
     virtualTriggering: { type: Boolean },
     zIndex: {}
@@ -45,138 +46,109 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     "blur",
     "close"
   ],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const emit = __emit;
-    const instance = getCurrentInstance();
-    const {
-      focusStartRef,
-      trapped,
-      onFocusAfterReleased,
-      onFocusAfterTrapped,
-      onFocusInTrap,
-      onFocusoutPrevented,
-      onReleaseRequested
-    } = usePopperContentFocusTrap(instance.props, emit);
-    const { attributes, arrowRef, contentRef, styles, instanceRef, role, update } = usePopperContent(instance.props);
-    const {
-      ariaModal,
-      arrowStyle,
-      contentAttrs,
-      contentClass,
-      contentStyle,
-      updateZIndex
-    } = usePopperContentDOM(instance.props, {
-      styles,
-      attributes,
-      role
-    });
-    const formItemContext = inject(formItemContextKey, void 0);
-    provide(POPPER_CONTENT_INJECTION_KEY, {
-      arrowStyle,
-      arrowRef
+  setup(o, { expose: F, emit: B }) {
+    const E = B, u = D(), {
+      focusStartRef: I,
+      trapped: p,
+      onFocusAfterReleased: T,
+      onFocusAfterTrapped: S,
+      onFocusInTrap: O,
+      onFocusoutPrevented: N,
+      onReleaseRequested: M
+    } = re(u.props, E), { attributes: w, arrowRef: x, contentRef: n, styles: k, instanceRef: h, role: d, update: j } = te(u.props), {
+      ariaModal: q,
+      arrowStyle: V,
+      contentAttrs: $,
+      contentClass: K,
+      contentStyle: c,
+      updateZIndex: L
+    } = oe(u.props, {
+      styles: k,
+      attributes: w,
+      role: d
+    }), m = J(A, void 0);
+    y(ae, {
+      arrowStyle: V,
+      arrowRef: x
+    }), m && y(A, {
+      ...m,
+      addInputId: R,
+      removeInputId: R
     });
-    if (formItemContext) {
-      provide(formItemContextKey, {
-        ...formItemContext,
-        addInputId: noop,
-        removeInputId: noop
-      });
-    }
-    let triggerTargetAriaStopWatch = void 0;
-    const updatePopper = (shouldUpdateZIndex = true) => {
-      update();
-      shouldUpdateZIndex && updateZIndex();
+    let l;
+    const v = (r = !0) => {
+      j(), r && L();
+    }, z = () => {
+      v(!1), o.visible && o.focusOnShow ? p.value = !0 : o.visible === !1 && (p.value = !1);
     };
-    const togglePopperAlive = () => {
-      updatePopper(false);
-      if (__props.visible && __props.focusOnShow) {
-        trapped.value = true;
-      } else if (__props.visible === false) {
-        trapped.value = false;
-      }
-    };
-    onMounted(() => {
-      watch(
-        () => __props.triggerTargetEl,
-        (triggerTargetEl, prevTriggerTargetEl) => {
-          triggerTargetAriaStopWatch?.();
-          triggerTargetAriaStopWatch = void 0;
-          const el = unref(triggerTargetEl || contentRef.value);
-          const prevEl = unref(prevTriggerTargetEl || contentRef.value);
-          if (isElement(el)) {
-            triggerTargetAriaStopWatch = watch(
-              [role, () => __props.ariaLabel, ariaModal, () => __props.id],
-              (watches) => {
-                ["role", "aria-label", "aria-modal", "id"].forEach((key, idx) => {
-                  isNil(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
-                });
-              },
-              { immediate: true }
-            );
-          }
-          if (prevEl !== el && isElement(prevEl)) {
-            ["role", "aria-label", "aria-modal", "id"].forEach((key) => {
-              prevEl.removeAttribute(key);
-            });
-          }
+    return U(() => {
+      f(
+        () => o.triggerTargetEl,
+        (r, a) => {
+          l?.(), l = void 0;
+          const t = e(r || n.value), i = e(a || n.value);
+          P(t) && (l = f(
+            [d, () => o.ariaLabel, q, () => o.id],
+            (s) => {
+              ["role", "aria-label", "aria-modal", "id"].forEach((g, b) => {
+                ee(s[b]) ? t.removeAttribute(g) : t.setAttribute(g, s[b]);
+              });
+            },
+            { immediate: !0 }
+          )), i !== t && P(i) && ["role", "aria-label", "aria-modal", "id"].forEach((s) => {
+            i.removeAttribute(s);
+          });
         },
-        { immediate: true }
-      );
-      watch(() => __props.visible, togglePopperAlive, { immediate: true });
-    });
-    onBeforeUnmount(() => {
-      triggerTargetAriaStopWatch?.();
-      triggerTargetAriaStopWatch = void 0;
-    });
-    __expose({
+        { immediate: !0 }
+      ), f(() => o.visible, z, { immediate: !0 });
+    }), W(() => {
+      l?.(), l = void 0;
+    }), F({
       /**
        * @description popper content element
        */
-      popperContentRef: contentRef,
+      popperContentRef: n,
       /**
        * @description popperjs instance
        */
-      popperInstanceRef: instanceRef,
+      popperInstanceRef: h,
       /**
        * @description method for updating popper
        */
-      updatePopper,
+      updatePopper: v,
       /**
        * @description content style
        */
-      contentStyle
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", mergeProps({
-        ref_key: "contentRef",
-        ref: contentRef
-      }, unref(contentAttrs), {
-        style: unref(contentStyle),
-        class: unref(contentClass),
-        tabindex: "-1",
-        onMouseenter: _cache[0] || (_cache[0] = (e) => _ctx.$emit("mouseenter", e)),
-        onMouseleave: _cache[1] || (_cache[1] = (e) => _ctx.$emit("mouseleave", e))
-      }), [
-        createVNode(unref(VftFocusTrap), {
-          trapped: unref(trapped),
-          "trap-on-focus-in": true,
-          "focus-trap-el": unref(contentRef),
-          "focus-start-el": unref(focusStartRef),
-          onFocusAfterTrapped: unref(onFocusAfterTrapped),
-          onFocusAfterReleased: unref(onFocusAfterReleased),
-          onFocusin: unref(onFocusInTrap),
-          onFocusoutPrevented: unref(onFocusoutPrevented),
-          onReleaseRequested: unref(onReleaseRequested)
-        }, {
-          default: withCtx(() => [
-            renderSlot(_ctx.$slots, "default")
-          ]),
-          _: 3
-        }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
-      ], 16);
-    };
+      contentStyle: c
+    }), (r, a) => (Z(), Y("div", G({
+      ref_key: "contentRef",
+      ref: n
+    }, e($), {
+      style: e(c),
+      class: e(K),
+      tabindex: "-1",
+      onMouseenter: a[0] || (a[0] = (t) => r.$emit("mouseenter", t)),
+      onMouseleave: a[1] || (a[1] = (t) => r.$emit("mouseleave", t))
+    }), [
+      H(e(_), {
+        trapped: e(p),
+        "trap-on-focus-in": !0,
+        "focus-trap-el": e(n),
+        "focus-start-el": e(I),
+        onFocusAfterTrapped: e(S),
+        onFocusAfterReleased: e(T),
+        onFocusin: e(O),
+        onFocusoutPrevented: e(N),
+        onReleaseRequested: e(M)
+      }, {
+        default: Q(() => [
+          X(r.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
+    ], 16));
   }
 });
 export {
-  _sfc_main as default
+  be as default
 };

package/es/components/popper/index.js

@@ -1,13 +1,18 @@
-import { default as default2 } from "./arrow.vue2.js";
-import { default as default3 } from "./content.vue2.js";
-import _sfc_main from "./popper.vue2.js";
-import { default as default4 } from "./trigger.vue2.js";
-import { withInstall } from "../../utils/vue/install.js";
-const VftPopper = withInstall(_sfc_main);
+import "@vueuse/core";
+import "@vft/utils";
+import "../config-provider/hooks/use-global-config.js";
+import "vue";
+import { withInstall as r } from "../../utils/vue/install.js";
+import "lodash-es";
+import { default as d } from "./arrow.vue2.js";
+import { default as x } from "./content.vue2.js";
+import t from "./popper.vue2.js";
+import { default as V } from "./trigger.vue2.js";
+const s = r(t);
 export {
-  VftPopper,
-  default2 as VftPopperArrow,
-  default3 as VftPopperContent,
-  default4 as VftPopperTrigger,
-  VftPopper as default
+  s as VftPopper,
+  d as VftPopperArrow,
+  x as VftPopperContent,
+  V as VftPopperTrigger,
+  s as default
 };

package/es/components/popper/popper.vue.js

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

package/es/components/popper/popper.vue2.js

@@ -1,49 +1,39 @@
-import { defineComponent, ref, computed, provide, renderSlot } from "vue";
-import { POPPER_INJECTION_KEY } from "./constants.js";
-const __default__ = defineComponent({
+import { defineComponent as t, ref as e, computed as i, provide as _, renderSlot as d } from "vue";
+import { POPPER_INJECTION_KEY as m } from "./constants.js";
+const u = t({
   name: "VftPopper",
-  inheritAttrs: false
-});
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
+  inheritAttrs: !1
+}), I = /* @__PURE__ */ t({
+  ...u,
   props: {
     role: { default: "tooltip" }
   },
-  setup(__props, { expose: __expose }) {
-    const triggerRef = ref();
-    const popperInstanceRef = ref();
-    const contentRef = ref();
-    const referenceRef = ref();
-    const _role = computed(() => __props.role);
-    const popperProvides = {
+  setup(r, { expose: n }) {
+    const p = e(), s = e(), f = e(), c = e(), l = i(() => r.role), o = {
       /**
        * @description trigger element
        */
-      triggerRef,
+      triggerRef: p,
       /**
        * @description popperjs instance
        */
-      popperInstanceRef,
+      popperInstanceRef: s,
       /**
        * @description popper content element
        */
-      contentRef,
+      contentRef: f,
       /**
        * @description popper reference element
        */
-      referenceRef,
+      referenceRef: c,
       /**
        * @description role determines how aria attributes are distributed
        */
-      role: _role
-    };
-    __expose(popperProvides);
-    provide(POPPER_INJECTION_KEY, popperProvides);
-    return (_ctx, _cache) => {
-      return renderSlot(_ctx.$slots, "default");
+      role: l
     };
+    return n(o), _(m, o), (a, P) => d(a.$slots, "default");
   }
 });
 export {
-  _sfc_main as default
+  I as default
 };

package/es/components/popper/style/css.js

@@ -1 +1,2 @@
-
+import "vft/theme-style/base.css";
+import "vft/theme-style/vft-popper.css";

package/es/components/popper/style/index.js

@@ -1 +1,2 @@
-
+import "vft/theme-style/src/base.scss";
+import "vft/theme-style/src/popper.scss";

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

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