vft 0.0.369 → 0.0.371

package/es/components/focus-trap/focus-trap.vue2.js

@@ -1,13 +1,13 @@
-import { EVENT_CODE } from "@vft/constants";
-import { useEscapeKeydown } from "@vft/use";
-import { isString } from "@vft/utils";
-import { isNil } from "lodash-es";
-import { defineComponent, ref, provide, watch, unref, onMounted, onBeforeUnmount, nextTick } from "vue";
-import { ON_TRAP_FOCUS_EVT, ON_RELEASE_FOCUS_EVT, FOCUS_TRAP_INJECTION_KEY, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_AFTER_RELEASED } from "./tokens.js";
-import { useFocusReason, tryFocus, createFocusOutPreventedEvent, getEdges, focusableStack, focusFirstDescendant, obtainAllFocusableElements, isFocusCausedByUserEvent } from "./utils.js";
-const _sfc_main = defineComponent({
+import { EVENT_CODE as V } from "@vft/constants";
+import { useEscapeKeydown as j } from "@vft/use";
+import { isString as q } from "@vft/utils";
+import { isNil as x } from "lodash-es";
+import { defineComponent as J, ref as M, provide as Y, watch as b, unref as p, onMounted as z, onBeforeUnmount as G, nextTick as U } from "vue";
+import { ON_TRAP_FOCUS_EVT as K, ON_RELEASE_FOCUS_EVT as k, FOCUS_TRAP_INJECTION_KEY as H, FOCUS_AFTER_TRAPPED as y, FOCUS_AFTER_TRAPPED_OPTS as N, FOCUS_AFTER_RELEASED as L } from "./tokens.js";
+import { useFocusReason as Q, tryFocus as f, createFocusOutPreventedEvent as m, getEdges as W, focusableStack as B, focusFirstDescendant as X, obtainAllFocusableElements as Z, isFocusCausedByUserEvent as $ } from "./utils.js";
+const ce = J({
   name: "VftFocusTrap",
-  inheritAttrs: false,
+  inheritAttrs: !1,
   props: {
     loop: Boolean,
     trapped: Boolean,
@@ -18,241 +18,140 @@ const _sfc_main = defineComponent({
     }
   },
   emits: [
-    ON_TRAP_FOCUS_EVT,
-    ON_RELEASE_FOCUS_EVT,
+    K,
+    k,
     "focusin",
     "focusout",
     "focusout-prevented",
     "release-requested"
   ],
-  setup(props, { emit }) {
-    const forwardRef = ref();
-    let lastFocusBeforeTrapped;
-    let lastFocusAfterTrapped;
-    const { focusReason } = useFocusReason();
-    useEscapeKeydown((event) => {
-      if (props.trapped && !focusLayer.paused) {
-        emit("release-requested", event);
-      }
+  setup(n, { emit: u }) {
+    const s = M();
+    let l, T;
+    const { focusReason: d } = Q();
+    j((e) => {
+      n.trapped && !i.paused && u("release-requested", e);
     });
-    const focusLayer = {
-      paused: false,
+    const i = {
+      paused: !1,
       pause() {
-        this.paused = true;
+        this.paused = !0;
       },
       resume() {
-        this.paused = false;
+        this.paused = !1;
       }
-    };
-    const onKeydown = (e) => {
-      if (!props.loop && !props.trapped) return;
-      if (focusLayer.paused) return;
-      const { code, altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
-      const { loop } = props;
-      const isTabbing = code === EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
-      const currentFocusingEl = document.activeElement;
-      if (isTabbing && currentFocusingEl) {
-        const container = currentTarget;
-        const [first, last] = getEdges(container);
-        const isTabbable = first && last;
-        if (!isTabbable) {
-          if (currentFocusingEl === container) {
-            const focusoutPreventedEvent = createFocusOutPreventedEvent({
-              focusReason: focusReason.value
-            });
-            emit("focusout-prevented", focusoutPreventedEvent);
-            if (!focusoutPreventedEvent.defaultPrevented) {
-              e.preventDefault();
-            }
-          }
-        } else {
-          if (!shiftKey && currentFocusingEl === last) {
-            const focusoutPreventedEvent = createFocusOutPreventedEvent({
-              focusReason: focusReason.value
+    }, v = (e) => {
+      if (!n.loop && !n.trapped || i.paused) return;
+      const { code: t, altKey: o, ctrlKey: a, metaKey: r, currentTarget: h, shiftKey: D } = e, { loop: I } = n, w = t === V.tab && !o && !a && !r, E = document.activeElement;
+      if (w && E) {
+        const _ = h, [C, O] = W(_);
+        if (C && O) {
+          if (!D && E === O) {
+            const c = m({
+              focusReason: d.value
             });
-            emit("focusout-prevented", focusoutPreventedEvent);
-            if (!focusoutPreventedEvent.defaultPrevented) {
-              e.preventDefault();
-              if (loop) tryFocus(first, true);
-            }
-          } else if (shiftKey && [first, container].includes(currentFocusingEl)) {
-            const focusoutPreventedEvent = createFocusOutPreventedEvent({
-              focusReason: focusReason.value
+            u("focusout-prevented", c), c.defaultPrevented || (e.preventDefault(), I && f(C, !0));
+          } else if (D && [C, _].includes(E)) {
+            const c = m({
+              focusReason: d.value
             });
-            emit("focusout-prevented", focusoutPreventedEvent);
-            if (!focusoutPreventedEvent.defaultPrevented) {
-              e.preventDefault();
-              if (loop) tryFocus(last, true);
-            }
+            u("focusout-prevented", c), c.defaultPrevented || (e.preventDefault(), I && f(O, !0));
           }
+        } else if (E === _) {
+          const c = m({
+            focusReason: d.value
+          });
+          u("focusout-prevented", c), c.defaultPrevented || e.preventDefault();
         }
       }
     };
-    provide(FOCUS_TRAP_INJECTION_KEY, {
-      focusTrapRef: forwardRef,
-      onKeydown
-    });
-    watch(
-      () => props.focusTrapEl,
-      (focusTrapEl) => {
-        if (focusTrapEl) {
-          forwardRef.value = focusTrapEl;
-        }
+    Y(H, {
+      focusTrapRef: s,
+      onKeydown: v
+    }), b(
+      () => n.focusTrapEl,
+      (e) => {
+        e && (s.value = e);
       },
-      { immediate: true }
-    );
-    watch([forwardRef], ([forwardRef2], [oldForwardRef]) => {
-      if (forwardRef2) {
-        forwardRef2.addEventListener("keydown", onKeydown);
-        forwardRef2.addEventListener("focusin", onFocusIn);
-        forwardRef2.addEventListener("focusout", onFocusOut);
-      }
-      if (oldForwardRef) {
-        oldForwardRef.removeEventListener("keydown", onKeydown);
-        oldForwardRef.removeEventListener("focusin", onFocusIn);
-        oldForwardRef.removeEventListener("focusout", onFocusOut);
-      }
+      { immediate: !0 }
+    ), b([s], ([e], [t]) => {
+      e && (e.addEventListener("keydown", v), e.addEventListener("focusin", F), e.addEventListener("focusout", P)), t && (t.removeEventListener("keydown", v), t.removeEventListener("focusin", F), t.removeEventListener("focusout", P));
     });
-    const trapOnFocus = (e) => {
-      emit(ON_TRAP_FOCUS_EVT, e);
-    };
-    const releaseOnFocus = (e) => emit(ON_RELEASE_FOCUS_EVT, e);
-    const onFocusIn = (e) => {
-      const trapContainer = unref(forwardRef);
-      if (!trapContainer) return;
-      const target = e.target;
-      const relatedTarget = e.relatedTarget;
-      const isFocusedInTrap = target && trapContainer.contains(target);
-      if (!props.trapped) {
-        const isPrevFocusedInTrap = relatedTarget && trapContainer.contains(relatedTarget);
-        if (!isPrevFocusedInTrap) {
-          lastFocusBeforeTrapped = relatedTarget;
-        }
-      }
-      if (isFocusedInTrap) emit("focusin", e);
-      if (focusLayer.paused) return;
-      if (props.trapped) {
-        if (isFocusedInTrap) {
-          lastFocusAfterTrapped = target;
-        } else {
-          tryFocus(lastFocusAfterTrapped, true);
-        }
-      }
-    };
-    const onFocusOut = (e) => {
-      const trapContainer = unref(forwardRef);
-      if (focusLayer.paused || !trapContainer) return;
-      if (props.trapped) {
-        const relatedTarget = e.relatedTarget;
-        if (!isNil(relatedTarget) && !trapContainer.contains(relatedTarget)) {
-          setTimeout(() => {
-            if (!focusLayer.paused && props.trapped) {
-              const focusoutPreventedEvent = createFocusOutPreventedEvent({
-                focusReason: focusReason.value
+    const g = (e) => {
+      u(K, e);
+    }, S = (e) => u(k, e), F = (e) => {
+      const t = p(s);
+      if (!t) return;
+      const o = e.target, a = e.relatedTarget, r = o && t.contains(o);
+      n.trapped || a && t.contains(a) || (l = a), r && u("focusin", e), !i.paused && n.trapped && (r ? T = o : f(T, !0));
+    }, P = (e) => {
+      const t = p(s);
+      if (!(i.paused || !t))
+        if (n.trapped) {
+          const o = e.relatedTarget;
+          !x(o) && !t.contains(o) && setTimeout(() => {
+            if (!i.paused && n.trapped) {
+              const a = m({
+                focusReason: d.value
               });
-              emit("focusout-prevented", focusoutPreventedEvent);
-              if (!focusoutPreventedEvent.defaultPrevented) {
-                tryFocus(lastFocusAfterTrapped, true);
-              }
+              u("focusout-prevented", a), a.defaultPrevented || f(T, !0);
             }
           }, 0);
+        } else {
+          const o = e.target;
+          o && t.contains(o) || u("focusout", e);
         }
-      } else {
-        const target = e.target;
-        const isFocusedInTrap = target && trapContainer.contains(target);
-        if (!isFocusedInTrap) emit("focusout", e);
-      }
     };
-    async function startTrap() {
-      await nextTick();
-      const trapContainer = unref(forwardRef);
-      if (trapContainer) {
-        focusableStack.push(focusLayer);
-        const prevFocusedElement = trapContainer.contains(
+    async function A() {
+      await U();
+      const e = p(s);
+      if (e) {
+        B.push(i);
+        const t = e.contains(
           document.activeElement
-        ) ? lastFocusBeforeTrapped : document.activeElement;
-        lastFocusBeforeTrapped = prevFocusedElement;
-        const isPrevFocusContained = trapContainer.contains(prevFocusedElement);
-        if (!isPrevFocusContained) {
-          const focusEvent = new Event(
-            FOCUS_AFTER_TRAPPED,
-            FOCUS_AFTER_TRAPPED_OPTS
+        ) ? l : document.activeElement;
+        if (l = t, !e.contains(t)) {
+          const a = new Event(
+            y,
+            N
           );
-          trapContainer.addEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
-          trapContainer.dispatchEvent(focusEvent);
-          if (!focusEvent.defaultPrevented) {
-            nextTick(() => {
-              let focusStartEl = props.focusStartEl;
-              if (!isString(focusStartEl)) {
-                tryFocus(focusStartEl);
-                if (document.activeElement !== focusStartEl) {
-                  focusStartEl = "first";
-                }
-              }
-              if (focusStartEl === "first") {
-                focusFirstDescendant(
-                  obtainAllFocusableElements(trapContainer),
-                  true
-                );
-              }
-              if (document.activeElement === prevFocusedElement || focusStartEl === "container") {
-                tryFocus(trapContainer);
-              }
-            });
-          }
+          e.addEventListener(y, g), e.dispatchEvent(a), a.defaultPrevented || U(() => {
+            let r = n.focusStartEl;
+            q(r) || (f(r), document.activeElement !== r && (r = "first")), r === "first" && X(
+              Z(e),
+              !0
+            ), (document.activeElement === t || r === "container") && f(e);
+          });
         }
       }
     }
-    function stopTrap() {
-      const trapContainer = unref(forwardRef);
-      if (trapContainer) {
-        trapContainer.removeEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
-        const releasedEvent = new CustomEvent(FOCUS_AFTER_RELEASED, {
-          ...FOCUS_AFTER_TRAPPED_OPTS,
+    function R() {
+      const e = p(s);
+      if (e) {
+        e.removeEventListener(y, g);
+        const t = new CustomEvent(L, {
+          ...N,
           detail: {
-            focusReason: focusReason.value
+            focusReason: d.value
           }
         });
-        trapContainer.addEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
-        trapContainer.dispatchEvent(releasedEvent);
-        if (!releasedEvent.defaultPrevented && (focusReason.value == "keyboard" || !isFocusCausedByUserEvent() || trapContainer.contains(document.activeElement))) {
-          tryFocus(lastFocusBeforeTrapped ?? document.body);
-        }
-        trapContainer.removeEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
-        focusableStack.remove(focusLayer);
+        e.addEventListener(L, S), e.dispatchEvent(t), !t.defaultPrevented && (d.value == "keyboard" || !$() || e.contains(document.activeElement)) && f(l ?? document.body), e.removeEventListener(L, S), B.remove(i);
       }
     }
-    onMounted(() => {
-      if (props.trapped) {
-        startTrap();
-      }
-      watch(
-        () => props.trapped,
-        (trapped) => {
-          if (trapped) {
-            startTrap();
-          } else {
-            stopTrap();
-          }
+    return z(() => {
+      n.trapped && A(), b(
+        () => n.trapped,
+        (e) => {
+          e ? A() : R();
         }
       );
-    });
-    onBeforeUnmount(() => {
-      if (props.trapped) {
-        stopTrap();
-      }
-      if (forwardRef.value) {
-        forwardRef.value.removeEventListener("keydown", onKeydown);
-        forwardRef.value.removeEventListener("focusin", onFocusIn);
-        forwardRef.value.removeEventListener("focusout", onFocusOut);
-        forwardRef.value = void 0;
-      }
-    });
-    return {
-      onKeydown
+    }), G(() => {
+      n.trapped && R(), s.value && (s.value.removeEventListener("keydown", v), s.value.removeEventListener("focusin", F), s.value.removeEventListener("focusout", P), s.value = void 0);
+    }), {
+      onKeydown: v
     };
   }
 });
 export {
-  _sfc_main as default
+  ce as default
 };

package/es/components/focus-trap/index.js

@@ -1,25 +1,25 @@
-import VftFocusTrap from "./focus-trap.vue.js";
-import { FOCUSOUT_PREVENTED, FOCUSOUT_PREVENTED_OPTS, FOCUS_AFTER_RELEASED, FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS, FOCUS_TRAP_INJECTION_KEY, ON_RELEASE_FOCUS_EVT, ON_TRAP_FOCUS_EVT } from "./tokens.js";
-import { createFocusOutPreventedEvent, focusFirstDescendant, focusableStack, getEdges, getVisibleElement, isFocusCausedByUserEvent, isHidden, obtainAllFocusableElements, tryFocus, useFocusReason } from "./utils.js";
+import E from "./focus-trap.vue.js";
+import { FOCUSOUT_PREVENTED as _, FOCUSOUT_PREVENTED_OPTS as F, FOCUS_AFTER_RELEASED as o, FOCUS_AFTER_TRAPPED as T, FOCUS_AFTER_TRAPPED_OPTS as O, FOCUS_TRAP_INJECTION_KEY as r, ON_RELEASE_FOCUS_EVT as S, ON_TRAP_FOCUS_EVT as u } from "./tokens.js";
+import { createFocusOutPreventedEvent as a, focusFirstDescendant as c, focusableStack as P, getEdges as U, getVisibleElement as n, isFocusCausedByUserEvent as A, isHidden as C, obtainAllFocusableElements as i, tryFocus as l, useFocusReason as d } from "./utils.js";
 export {
-  FOCUSOUT_PREVENTED,
-  FOCUSOUT_PREVENTED_OPTS,
-  FOCUS_AFTER_RELEASED,
-  FOCUS_AFTER_TRAPPED,
-  FOCUS_AFTER_TRAPPED_OPTS,
-  FOCUS_TRAP_INJECTION_KEY,
-  ON_RELEASE_FOCUS_EVT,
-  ON_TRAP_FOCUS_EVT,
-  VftFocusTrap,
-  createFocusOutPreventedEvent,
-  VftFocusTrap as default,
-  focusFirstDescendant,
-  focusableStack,
-  getEdges,
-  getVisibleElement,
-  isFocusCausedByUserEvent,
-  isHidden,
-  obtainAllFocusableElements,
-  tryFocus,
-  useFocusReason
+  _ as FOCUSOUT_PREVENTED,
+  F as FOCUSOUT_PREVENTED_OPTS,
+  o as FOCUS_AFTER_RELEASED,
+  T as FOCUS_AFTER_TRAPPED,
+  O as FOCUS_AFTER_TRAPPED_OPTS,
+  r as FOCUS_TRAP_INJECTION_KEY,
+  S as ON_RELEASE_FOCUS_EVT,
+  u as ON_TRAP_FOCUS_EVT,
+  E as VftFocusTrap,
+  a as createFocusOutPreventedEvent,
+  E as default,
+  c as focusFirstDescendant,
+  P as focusableStack,
+  U as getEdges,
+  n as getVisibleElement,
+  A as isFocusCausedByUserEvent,
+  C as isHidden,
+  i as obtainAllFocusableElements,
+  l as tryFocus,
+  d as useFocusReason
 };

package/es/components/focus-trap/tokens.js

@@ -1,24 +1,17 @@
-const FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
-const FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
-const FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
-const FOCUS_AFTER_TRAPPED_OPTS = {
-  cancelable: true,
-  bubbles: false
-};
-const FOCUSOUT_PREVENTED_OPTS = {
-  cancelable: true,
-  bubbles: false
-};
-const ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
-const ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
-const FOCUS_TRAP_INJECTION_KEY = Symbol("vftFocusTrap");
+const e = "focus-trap.focus-after-trapped", s = "focus-trap.focus-after-released", t = "focus-trap.focusout-prevented", c = {
+  cancelable: !0,
+  bubbles: !1
+}, E = {
+  cancelable: !0,
+  bubbles: !1
+}, o = "focusAfterTrapped", _ = "focusAfterReleased", T = Symbol("vftFocusTrap");
 export {
-  FOCUSOUT_PREVENTED,
-  FOCUSOUT_PREVENTED_OPTS,
-  FOCUS_AFTER_RELEASED,
-  FOCUS_AFTER_TRAPPED,
-  FOCUS_AFTER_TRAPPED_OPTS,
-  FOCUS_TRAP_INJECTION_KEY,
-  ON_RELEASE_FOCUS_EVT,
-  ON_TRAP_FOCUS_EVT
+  t as FOCUSOUT_PREVENTED,
+  E as FOCUSOUT_PREVENTED_OPTS,
+  s as FOCUS_AFTER_RELEASED,
+  e as FOCUS_AFTER_TRAPPED,
+  c as FOCUS_AFTER_TRAPPED_OPTS,
+  T as FOCUS_TRAP_INJECTION_KEY,
+  _ as ON_RELEASE_FOCUS_EVT,
+  o as ON_TRAP_FOCUS_EVT
 };