@commercetools/nimbus 2.7.0 → 2.9.0

package/dist/chunks/FocusScope-D_JoB-Y8.es.js

@@ -0,0 +1,623 @@
+import { h as G, $ as F, d as m, b as $, i as j, j as B, a as x, k as V } from "./utils-CjZmL8XS.es.js";
+import { c as T } from "./mergeProps-Dg8WqJiN.es.js";
+import { d as Q, e as X, b as Y } from "./useFocusVisible-DY8qx7TG.es.js";
+import { $ as Z } from "./focusSafely-DfbNI-gf.es.js";
+import y, { useRef as S, useContext as O, useMemo as I, useEffect as U } from "react";
+class ee {
+  get currentNode() {
+    return this._currentNode;
+  }
+  set currentNode(e) {
+    if (!F(this.root, e)) throw new Error("Cannot set currentNode to a node that is not contained by the root node.");
+    const t = [];
+    let n = e, o = e;
+    for (this._currentNode = e; n && n !== this.root; ) if (n.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      const l = n, i = this._doc.createTreeWalker(l, this.whatToShow, {
+        acceptNode: this._acceptNode
+      });
+      t.push(i), i.currentNode = o, this._currentSetFor.add(i), n = o = l.host;
+    } else n = n.parentNode;
+    const a = this._doc.createTreeWalker(this.root, this.whatToShow, {
+      acceptNode: this._acceptNode
+    });
+    t.push(a), a.currentNode = o, this._currentSetFor.add(a), this._walkerStack = t;
+  }
+  get doc() {
+    return this._doc;
+  }
+  firstChild() {
+    let e = this.currentNode, t = this.nextNode();
+    return F(e, t) ? (t && (this.currentNode = t), t) : (this.currentNode = e, null);
+  }
+  lastChild() {
+    let t = this._walkerStack[0].lastChild();
+    return t && (this.currentNode = t), t;
+  }
+  nextNode() {
+    const e = this._walkerStack[0].nextNode();
+    if (e) {
+      if (e.shadowRoot) {
+        var t;
+        let o;
+        if (typeof this.filter == "function" ? o = this.filter(e) : !((t = this.filter) === null || t === void 0) && t.acceptNode && (o = this.filter.acceptNode(e)), o === NodeFilter.FILTER_ACCEPT)
+          return this.currentNode = e, e;
+        let a = this.nextNode();
+        return a && (this.currentNode = a), a;
+      }
+      return e && (this.currentNode = e), e;
+    } else if (this._walkerStack.length > 1) {
+      this._walkerStack.shift();
+      let n = this.nextNode();
+      return n && (this.currentNode = n), n;
+    } else return null;
+  }
+  previousNode() {
+    const e = this._walkerStack[0];
+    if (e.currentNode === e.root) {
+      if (this._currentSetFor.has(e))
+        if (this._currentSetFor.delete(e), this._walkerStack.length > 1) {
+          this._walkerStack.shift();
+          let o = this.previousNode();
+          return o && (this.currentNode = o), o;
+        } else return null;
+      return null;
+    }
+    const t = e.previousNode();
+    if (t) {
+      if (t.shadowRoot) {
+        var n;
+        let a;
+        if (typeof this.filter == "function" ? a = this.filter(t) : !((n = this.filter) === null || n === void 0) && n.acceptNode && (a = this.filter.acceptNode(t)), a === NodeFilter.FILTER_ACCEPT)
+          return t && (this.currentNode = t), t;
+        let l = this.lastChild();
+        return l && (this.currentNode = l), l;
+      }
+      return t && (this.currentNode = t), t;
+    } else if (this._walkerStack.length > 1) {
+      this._walkerStack.shift();
+      let o = this.previousNode();
+      return o && (this.currentNode = o), o;
+    } else return null;
+  }
+  /**
+   * @deprecated
+   */
+  nextSibling() {
+    return null;
+  }
+  /**
+   * @deprecated
+   */
+  previousSibling() {
+    return null;
+  }
+  /**
+   * @deprecated
+   */
+  parentNode() {
+    return null;
+  }
+  constructor(e, t, n, o) {
+    this._walkerStack = [], this._currentSetFor = /* @__PURE__ */ new Set(), this._acceptNode = (l) => {
+      if (l.nodeType === Node.ELEMENT_NODE) {
+        const b = l.shadowRoot;
+        if (b) {
+          const u = this._doc.createTreeWalker(b, this.whatToShow, {
+            acceptNode: this._acceptNode
+          });
+          return this._walkerStack.unshift(u), NodeFilter.FILTER_ACCEPT;
+        } else {
+          var i;
+          if (typeof this.filter == "function") return this.filter(l);
+          if (!((i = this.filter) === null || i === void 0) && i.acceptNode) return this.filter.acceptNode(l);
+          if (this.filter === null) return NodeFilter.FILTER_ACCEPT;
+        }
+      }
+      return NodeFilter.FILTER_SKIP;
+    }, this._doc = e, this.root = t, this.filter = o ?? null, this.whatToShow = n ?? NodeFilter.SHOW_ALL, this._currentNode = t, this._walkerStack.unshift(e.createTreeWalker(t, n, this._acceptNode));
+    const a = t.shadowRoot;
+    if (a) {
+      const l = this._doc.createTreeWalker(a, this.whatToShow, {
+        acceptNode: this._acceptNode
+      });
+      this._walkerStack.unshift(l);
+    }
+  }
+}
+function te(r, e, t, n) {
+  return G() ? new ee(r, e, t, n) : r.createTreeWalker(e, t, n);
+}
+const W = /* @__PURE__ */ y.createContext(null), A = "react-aria-focus-scope-restore";
+let h = null;
+function he(r) {
+  let { children: e, contain: t, restoreFocus: n, autoFocus: o } = r, a = S(null), l = S(null), i = S([]), { parentNode: b } = O(W) || {}, u = I(() => new P({
+    scopeRef: i
+  }), [
+    i
+  ]);
+  T(() => {
+    let s = b || v.root;
+    if (v.getTreeNode(s.scopeRef) && h && !C(h, s.scopeRef)) {
+      let f = v.getTreeNode(h);
+      f && (s = f);
+    }
+    s.addChild(u), v.addNode(u);
+  }, [
+    u,
+    b
+  ]), T(() => {
+    let s = v.getTreeNode(i);
+    s && (s.contain = !!t);
+  }, [
+    t
+  ]), T(() => {
+    var s;
+    let f = (s = a.current) === null || s === void 0 ? void 0 : s.nextSibling, N = [], _ = (L) => L.stopPropagation();
+    for (; f && f !== l.current; )
+      N.push(f), f.addEventListener(A, _), f = f.nextSibling;
+    return i.current = N, () => {
+      for (let L of N) L.removeEventListener(A, _);
+    };
+  }, [
+    e
+  ]), le(i, n, t), ie(i, t), ue(i, n, t), ae(i, o), U(() => {
+    const s = m($(i.current ? i.current[0] : void 0));
+    let f = null;
+    if (w(s, i.current)) {
+      for (let N of v.traverse()) N.scopeRef && w(s, N.scopeRef.current) && (f = N);
+      f === v.getTreeNode(i) && (h = f.scopeRef);
+    }
+  }, [
+    i
+  ]), T(() => () => {
+    var s, f, N;
+    let _ = (N = (f = v.getTreeNode(i)) === null || f === void 0 || (s = f.parent) === null || s === void 0 ? void 0 : s.scopeRef) !== null && N !== void 0 ? N : null;
+    (i === h || C(i, h)) && (!_ || v.getTreeNode(_)) && (h = _), v.removeTreeNode(i);
+  }, [
+    i
+  ]);
+  let d = I(() => re(i), []), c = I(() => ({
+    focusManager: d,
+    parentNode: u
+  }), [
+    u,
+    d
+  ]);
+  return /* @__PURE__ */ y.createElement(W.Provider, {
+    value: c
+  }, /* @__PURE__ */ y.createElement("span", {
+    "data-focus-scope-start": !0,
+    hidden: !0,
+    ref: a
+  }), e, /* @__PURE__ */ y.createElement("span", {
+    "data-focus-scope-end": !0,
+    hidden: !0,
+    ref: l
+  }));
+}
+function re(r) {
+  return {
+    focusNext(e = {}) {
+      let t = r.current, { from: n, tabbable: o, wrap: a, accept: l } = e;
+      var i;
+      let b = n || m($((i = t[0]) !== null && i !== void 0 ? i : void 0)), u = t[0].previousElementSibling, d = g(t), c = E(d, {
+        tabbable: o,
+        accept: l
+      }, t);
+      c.currentNode = w(b, t) ? b : u;
+      let s = c.nextNode();
+      return !s && a && (c.currentNode = u, s = c.nextNode()), s && p(s, !0), s;
+    },
+    focusPrevious(e = {}) {
+      let t = r.current, { from: n, tabbable: o, wrap: a, accept: l } = e;
+      var i;
+      let b = n || m($((i = t[0]) !== null && i !== void 0 ? i : void 0)), u = t[t.length - 1].nextElementSibling, d = g(t), c = E(d, {
+        tabbable: o,
+        accept: l
+      }, t);
+      c.currentNode = w(b, t) ? b : u;
+      let s = c.previousNode();
+      return !s && a && (c.currentNode = u, s = c.previousNode()), s && p(s, !0), s;
+    },
+    focusFirst(e = {}) {
+      let t = r.current, { tabbable: n, accept: o } = e, a = g(t), l = E(a, {
+        tabbable: n,
+        accept: o
+      }, t);
+      l.currentNode = t[0].previousElementSibling;
+      let i = l.nextNode();
+      return i && p(i, !0), i;
+    },
+    focusLast(e = {}) {
+      let t = r.current, { tabbable: n, accept: o } = e, a = g(t), l = E(a, {
+        tabbable: n,
+        accept: o
+      }, t);
+      l.currentNode = t[t.length - 1].nextElementSibling;
+      let i = l.previousNode();
+      return i && p(i, !0), i;
+    }
+  };
+}
+function g(r) {
+  return r[0].parentElement;
+}
+function R(r) {
+  let e = v.getTreeNode(h);
+  for (; e && e.scopeRef !== r; ) {
+    if (e.contain) return !1;
+    e = e.parent;
+  }
+  return !0;
+}
+function ne(r) {
+  if (!r.form)
+    return Array.from($(r).querySelectorAll(`input[type="radio"][name="${CSS.escape(r.name)}"]`)).filter((n) => !n.form);
+  const e = r.form.elements.namedItem(r.name);
+  let t = V(r);
+  return e instanceof t.RadioNodeList ? Array.from(e).filter((n) => n instanceof t.HTMLInputElement) : e instanceof t.HTMLInputElement ? [
+    e
+  ] : [];
+}
+function oe(r) {
+  if (r.checked) return !0;
+  const e = ne(r);
+  return e.length > 0 && !e.some((t) => t.checked);
+}
+function ie(r, e) {
+  let t = S(void 0), n = S(void 0);
+  T(() => {
+    let o = r.current;
+    if (!e) {
+      n.current && (cancelAnimationFrame(n.current), n.current = void 0);
+      return;
+    }
+    const a = $(o ? o[0] : void 0);
+    let l = (u) => {
+      if (u.key !== "Tab" || u.altKey || u.ctrlKey || u.metaKey || !R(r) || u.isComposing) return;
+      let d = m(a), c = r.current;
+      if (!c || !w(d, c)) return;
+      let s = g(c), f = E(s, {
+        tabbable: !0
+      }, c);
+      if (!d) return;
+      f.currentNode = d;
+      let N = u.shiftKey ? f.previousNode() : f.nextNode();
+      N || (f.currentNode = u.shiftKey ? c[c.length - 1].nextElementSibling : c[0].previousElementSibling, N = u.shiftKey ? f.previousNode() : f.nextNode()), u.preventDefault(), N && p(N, !0);
+    }, i = (u) => {
+      (!h || C(h, r)) && w(x(u), r.current) ? (h = r, t.current = x(u)) : R(r) && !k(x(u), r) ? t.current ? t.current.focus() : h && h.current && K(h.current) : R(r) && (t.current = x(u));
+    }, b = (u) => {
+      n.current && cancelAnimationFrame(n.current), n.current = requestAnimationFrame(() => {
+        let d = Y(), c = (d === "virtual" || d === null) && Q() && X(), s = m(a);
+        if (!c && s && R(r) && !k(s, r)) {
+          h = r;
+          let N = x(u);
+          if (N && N.isConnected) {
+            var f;
+            t.current = N, (f = t.current) === null || f === void 0 || f.focus();
+          } else h.current && K(h.current);
+        }
+      });
+    };
+    return a.addEventListener("keydown", l, !1), a.addEventListener("focusin", i, !1), o?.forEach((u) => u.addEventListener("focusin", i, !1)), o?.forEach((u) => u.addEventListener("focusout", b, !1)), () => {
+      a.removeEventListener("keydown", l, !1), a.removeEventListener("focusin", i, !1), o?.forEach((u) => u.removeEventListener("focusin", i, !1)), o?.forEach((u) => u.removeEventListener("focusout", b, !1));
+    };
+  }, [
+    r,
+    e
+  ]), T(() => () => {
+    n.current && cancelAnimationFrame(n.current);
+  }, [
+    n
+  ]);
+}
+function q(r) {
+  return k(r);
+}
+function w(r, e) {
+  return !r || !e ? !1 : e.some((t) => F(t, r));
+}
+function k(r, e = null) {
+  if (r instanceof Element && r.closest("[data-react-aria-top-layer]")) return !0;
+  for (let { scopeRef: t } of v.traverse(v.getTreeNode(e)))
+    if (t && w(r, t.current)) return !0;
+  return !1;
+}
+function Ne(r) {
+  return k(r, h);
+}
+function C(r, e) {
+  var t;
+  let n = (t = v.getTreeNode(e)) === null || t === void 0 ? void 0 : t.parent;
+  for (; n; ) {
+    if (n.scopeRef === r) return !0;
+    n = n.parent;
+  }
+  return !1;
+}
+function p(r, e = !1) {
+  if (r != null && !e) try {
+    Z(r);
+  } catch {
+  }
+  else if (r != null) try {
+    r.focus();
+  } catch {
+  }
+}
+function J(r, e = !0) {
+  let t = r[0].previousElementSibling, n = g(r), o = E(n, {
+    tabbable: e
+  }, r);
+  o.currentNode = t;
+  let a = o.nextNode();
+  return e && !a && (n = g(r), o = E(n, {
+    tabbable: !1
+  }, r), o.currentNode = t, a = o.nextNode()), a;
+}
+function K(r, e = !0) {
+  p(J(r, e));
+}
+function ae(r, e) {
+  const t = y.useRef(e);
+  U(() => {
+    if (t.current) {
+      h = r;
+      const n = $(r.current ? r.current[0] : void 0);
+      !w(m(n), h.current) && r.current && K(r.current);
+    }
+    t.current = !1;
+  }, [
+    r
+  ]);
+}
+function le(r, e, t) {
+  T(() => {
+    if (e || t) return;
+    let n = r.current;
+    const o = $(n ? n[0] : void 0);
+    let a = (l) => {
+      let i = x(l);
+      w(i, r.current) ? h = r : q(i) || (h = null);
+    };
+    return o.addEventListener("focusin", a, !1), n?.forEach((l) => l.addEventListener("focusin", a, !1)), () => {
+      o.removeEventListener("focusin", a, !1), n?.forEach((l) => l.removeEventListener("focusin", a, !1));
+    };
+  }, [
+    r,
+    e,
+    t
+  ]);
+}
+function z(r) {
+  let e = v.getTreeNode(h);
+  for (; e && e.scopeRef !== r; ) {
+    if (e.nodeToRestore) return !1;
+    e = e.parent;
+  }
+  return e?.scopeRef === r;
+}
+function ue(r, e, t) {
+  const n = S(typeof document < "u" ? m($(r.current ? r.current[0] : void 0)) : null);
+  T(() => {
+    let o = r.current;
+    const a = $(o ? o[0] : void 0);
+    if (!e || t) return;
+    let l = () => {
+      (!h || C(h, r)) && w(m(a), r.current) && (h = r);
+    };
+    return a.addEventListener("focusin", l, !1), o?.forEach((i) => i.addEventListener("focusin", l, !1)), () => {
+      a.removeEventListener("focusin", l, !1), o?.forEach((i) => i.removeEventListener("focusin", l, !1));
+    };
+  }, [
+    r,
+    t
+  ]), T(() => {
+    const o = $(r.current ? r.current[0] : void 0);
+    if (!e) return;
+    let a = (l) => {
+      if (l.key !== "Tab" || l.altKey || l.ctrlKey || l.metaKey || !R(r) || l.isComposing) return;
+      let i = o.activeElement;
+      if (!k(i, r) || !z(r)) return;
+      let b = v.getTreeNode(r);
+      if (!b) return;
+      let u = b.nodeToRestore, d = E(o.body, {
+        tabbable: !0
+      });
+      d.currentNode = i;
+      let c = l.shiftKey ? d.previousNode() : d.nextNode();
+      if ((!u || !u.isConnected || u === o.body) && (u = void 0, b.nodeToRestore = void 0), (!c || !k(c, r)) && u) {
+        d.currentNode = u;
+        do
+          c = l.shiftKey ? d.previousNode() : d.nextNode();
+        while (k(c, r));
+        l.preventDefault(), l.stopPropagation(), c ? p(c, !0) : q(u) ? p(u, !0) : i.blur();
+      }
+    };
+    return t || o.addEventListener("keydown", a, !0), () => {
+      t || o.removeEventListener("keydown", a, !0);
+    };
+  }, [
+    r,
+    e,
+    t
+  ]), T(() => {
+    const o = $(r.current ? r.current[0] : void 0);
+    if (!e) return;
+    let a = v.getTreeNode(r);
+    if (a) {
+      var l;
+      return a.nodeToRestore = (l = n.current) !== null && l !== void 0 ? l : void 0, () => {
+        let i = v.getTreeNode(r);
+        if (!i) return;
+        let b = i.nodeToRestore, u = m(o);
+        if (e && b && (u && k(u, r) || u === o.body && z(r))) {
+          let d = v.clone();
+          requestAnimationFrame(() => {
+            if (o.activeElement === o.body) {
+              let c = d.getTreeNode(r);
+              for (; c; ) {
+                if (c.nodeToRestore && c.nodeToRestore.isConnected) {
+                  H(c.nodeToRestore);
+                  return;
+                }
+                c = c.parent;
+              }
+              for (c = d.getTreeNode(r); c; ) {
+                if (c.scopeRef && c.scopeRef.current && v.getTreeNode(c.scopeRef)) {
+                  let s = J(c.scopeRef.current, !0);
+                  H(s);
+                  return;
+                }
+                c = c.parent;
+              }
+            }
+          });
+        }
+      };
+    }
+  }, [
+    r,
+    e
+  ]);
+}
+function H(r) {
+  r.dispatchEvent(new CustomEvent(A, {
+    bubbles: !0,
+    cancelable: !0
+  })) && p(r);
+}
+function E(r, e, t) {
+  let n = e?.tabbable ? j : B, o = r?.nodeType === Node.ELEMENT_NODE ? r : null, a = $(o), l = te(a, r || a, NodeFilter.SHOW_ELEMENT, {
+    acceptNode(i) {
+      return F(e?.from, i) || e?.tabbable && i.tagName === "INPUT" && i.getAttribute("type") === "radio" && (!oe(i) || l.currentNode.tagName === "INPUT" && l.currentNode.type === "radio" && l.currentNode.name === i.name) ? NodeFilter.FILTER_REJECT : n(i) && (!t || w(i, t)) && (!e?.accept || e.accept(i)) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  return e?.from && (l.currentNode = e.from), l;
+}
+function ve(r, e = {}) {
+  return {
+    focusNext(t = {}) {
+      let n = r.current;
+      if (!n) return null;
+      let { from: o, tabbable: a = e.tabbable, wrap: l = e.wrap, accept: i = e.accept } = t, b = o || m($(n)), u = E(n, {
+        tabbable: a,
+        accept: i
+      });
+      F(n, b) && (u.currentNode = b);
+      let d = u.nextNode();
+      return !d && l && (u.currentNode = n, d = u.nextNode()), d && p(d, !0), d;
+    },
+    focusPrevious(t = e) {
+      let n = r.current;
+      if (!n) return null;
+      let { from: o, tabbable: a = e.tabbable, wrap: l = e.wrap, accept: i = e.accept } = t, b = o || m($(n)), u = E(n, {
+        tabbable: a,
+        accept: i
+      });
+      if (F(n, b)) u.currentNode = b;
+      else {
+        let c = M(u);
+        return c && p(c, !0), c ?? null;
+      }
+      let d = u.previousNode();
+      if (!d && l) {
+        u.currentNode = n;
+        let c = M(u);
+        if (!c)
+          return null;
+        d = c;
+      }
+      return d && p(d, !0), d ?? null;
+    },
+    focusFirst(t = e) {
+      let n = r.current;
+      if (!n) return null;
+      let { tabbable: o = e.tabbable, accept: a = e.accept } = t, i = E(n, {
+        tabbable: o,
+        accept: a
+      }).nextNode();
+      return i && p(i, !0), i;
+    },
+    focusLast(t = e) {
+      let n = r.current;
+      if (!n) return null;
+      let { tabbable: o = e.tabbable, accept: a = e.accept } = t, l = E(n, {
+        tabbable: o,
+        accept: a
+      }), i = M(l);
+      return i && p(i, !0), i ?? null;
+    }
+  };
+}
+function M(r) {
+  let e, t;
+  do
+    t = r.lastChild(), t && (e = t);
+  while (t);
+  return e;
+}
+class D {
+  get size() {
+    return this.fastMap.size;
+  }
+  getTreeNode(e) {
+    return this.fastMap.get(e);
+  }
+  addTreeNode(e, t, n) {
+    let o = this.fastMap.get(t ?? null);
+    if (!o) return;
+    let a = new P({
+      scopeRef: e
+    });
+    o.addChild(a), a.parent = o, this.fastMap.set(e, a), n && (a.nodeToRestore = n);
+  }
+  addNode(e) {
+    this.fastMap.set(e.scopeRef, e);
+  }
+  removeTreeNode(e) {
+    if (e === null) return;
+    let t = this.fastMap.get(e);
+    if (!t) return;
+    let n = t.parent;
+    for (let a of this.traverse()) a !== t && t.nodeToRestore && a.nodeToRestore && t.scopeRef && t.scopeRef.current && w(a.nodeToRestore, t.scopeRef.current) && (a.nodeToRestore = t.nodeToRestore);
+    let o = t.children;
+    n && (n.removeChild(t), o.size > 0 && o.forEach((a) => n && n.addChild(a))), this.fastMap.delete(t.scopeRef);
+  }
+  // Pre Order Depth First
+  *traverse(e = this.root) {
+    if (e.scopeRef != null && (yield e), e.children.size > 0) for (let t of e.children) yield* this.traverse(t);
+  }
+  clone() {
+    var e;
+    let t = new D();
+    var n;
+    for (let o of this.traverse()) t.addTreeNode(o.scopeRef, (n = (e = o.parent) === null || e === void 0 ? void 0 : e.scopeRef) !== null && n !== void 0 ? n : null, o.nodeToRestore);
+    return t;
+  }
+  constructor() {
+    this.fastMap = /* @__PURE__ */ new Map(), this.root = new P({
+      scopeRef: null
+    }), this.fastMap.set(null, this.root);
+  }
+}
+class P {
+  addChild(e) {
+    this.children.add(e), e.parent = this;
+  }
+  removeChild(e) {
+    this.children.delete(e), e.parent = void 0;
+  }
+  constructor(e) {
+    this.children = /* @__PURE__ */ new Set(), this.contain = !1, this.scopeRef = e.scopeRef;
+  }
+}
+let v = /* @__PURE__ */ new D();
+export {
+  ve as $,
+  E as a,
+  he as b,
+  Ne as c,
+  te as d
+};
+//# sourceMappingURL=FocusScope-D_JoB-Y8.es.js.map