@worldcoin/mini-apps-ui-kit-react 1.0.0-canary.8 → 1.0.0

package/dist/node_modules/.pnpm/@radix-ui_react-focus-guards@1.1.1_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-focus-guards/dist/index.js

@@ -1,18 +1,30 @@
 "use client";
-import * as r from "react";
-var t = 0;
-function u() {
-  r.useEffect(() => {
-    const e = document.querySelectorAll("[data-radix-focus-guard]");
-    return document.body.insertAdjacentElement("afterbegin", e[0] ?? n()), document.body.insertAdjacentElement("beforeend", e[1] ?? n()), t++, () => {
-      t === 1 && document.querySelectorAll("[data-radix-focus-guard]").forEach((o) => o.remove()), t--;
+import * as React from "react";
+var count = 0;
+function useFocusGuards() {
+  React.useEffect(() => {
+    const edgeGuards = document.querySelectorAll("[data-radix-focus-guard]");
+    document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? createFocusGuard());
+    document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? createFocusGuard());
+    count++;
+    return () => {
+      if (count === 1) {
+        document.querySelectorAll("[data-radix-focus-guard]").forEach((node) => node.remove());
+      }
+      count--;
     };
   }, []);
 }
-function n() {
-  const e = document.createElement("span");
-  return e.setAttribute("data-radix-focus-guard", ""), e.tabIndex = 0, e.style.outline = "none", e.style.opacity = "0", e.style.position = "fixed", e.style.pointerEvents = "none", e;
+function createFocusGuard() {
+  const element = document.createElement("span");
+  element.setAttribute("data-radix-focus-guard", "");
+  element.tabIndex = 0;
+  element.style.outline = "none";
+  element.style.opacity = "0";
+  element.style.position = "fixed";
+  element.style.pointerEvents = "none";
+  return element;
 }
 export {
-  u as useFocusGuards
+  useFocusGuards
 };

package/dist/node_modules/.pnpm/@radix-ui_react-focus-scope@1.1.1_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@_4owg5o3kd7femmpae5yic5inii/node_modules/@radix-ui/react-focus-scope/dist/index.js

@@ -1,138 +1,209 @@
 "use client";
-import * as d from "react";
-import { useComposedRefs as R } from "../../../../../@radix-ui_react-compose-refs@1.1.1_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js";
-import { Primitive as M } from "../../../../../@radix-ui_react-primitive@2.0.1_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18_sspjpiczol7qxzbuuyfihuep4u/node_modules/@radix-ui/react-primitive/dist/index.js";
-import { useCallbackRef as y } from "../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js";
-import { jsx as _ } from "react/jsx-runtime";
-var F = "focusScope.autoFocusOnMount", T = "focusScope.autoFocusOnUnmount", N = { bubbles: !1, cancelable: !0 }, K = "FocusScope", k = d.forwardRef((e, n) => {
+import * as React from "react";
+import { useComposedRefs } from "../../../../../@radix-ui_react-compose-refs@1.1.1_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-compose-refs/dist/index.js";
+import { Primitive } from "../../../../../@radix-ui_react-primitive@2.0.1_@types_react-dom@18.3.5_@types_react@18.3.18__@types_react@18_sspjpiczol7qxzbuuyfihuep4u/node_modules/@radix-ui/react-primitive/dist/index.js";
+import { useCallbackRef } from "../../../../../@radix-ui_react-use-callback-ref@1.1.0_@types_react@18.3.18_react@18.3.1/node_modules/@radix-ui/react-use-callback-ref/dist/index.js";
+import { jsx } from "react/jsx-runtime";
+var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
+var AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
+var EVENT_OPTIONS = { bubbles: false, cancelable: true };
+var FOCUS_SCOPE_NAME = "FocusScope";
+var FocusScope = React.forwardRef((props, forwardedRef) => {
   const {
-    loop: t = !1,
-    trapped: u = !1,
-    onMountAutoFocus: p,
-    onUnmountAutoFocus: L,
-    ...g
-  } = e, [o, U] = d.useState(null), E = y(p), v = y(L), b = d.useRef(null), A = R(n, (s) => U(s)), a = d.useRef({
-    paused: !1,
+    loop = false,
+    trapped = false,
+    onMountAutoFocus: onMountAutoFocusProp,
+    onUnmountAutoFocus: onUnmountAutoFocusProp,
+    ...scopeProps
+  } = props;
+  const [container, setContainer] = React.useState(null);
+  const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);
+  const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);
+  const lastFocusedElementRef = React.useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, (node) => setContainer(node));
+  const focusScope = React.useRef({
+    paused: false,
     pause() {
-      this.paused = !0;
+      this.paused = true;
     },
     resume() {
-      this.paused = !1;
+      this.paused = false;
     }
   }).current;
-  d.useEffect(() => {
-    if (u) {
-      let s = function(i) {
-        if (a.paused || !o) return;
-        const c = i.target;
-        o.contains(c) ? b.current = c : f(b.current, { select: !0 });
-      }, l = function(i) {
-        if (a.paused || !o) return;
-        const c = i.relatedTarget;
-        c !== null && (o.contains(c) || f(b.current, { select: !0 }));
-      }, r = function(i) {
-        if (document.activeElement === document.body)
-          for (const h of i)
-            h.removedNodes.length > 0 && f(o);
+  React.useEffect(() => {
+    if (trapped) {
+      let handleFocusIn2 = function(event) {
+        if (focusScope.paused || !container) return;
+        const target = event.target;
+        if (container.contains(target)) {
+          lastFocusedElementRef.current = target;
+        } else {
+          focus(lastFocusedElementRef.current, { select: true });
+        }
+      }, handleFocusOut2 = function(event) {
+        if (focusScope.paused || !container) return;
+        const relatedTarget = event.relatedTarget;
+        if (relatedTarget === null) return;
+        if (!container.contains(relatedTarget)) {
+          focus(lastFocusedElementRef.current, { select: true });
+        }
+      }, handleMutations2 = function(mutations) {
+        const focusedElement = document.activeElement;
+        if (focusedElement !== document.body) return;
+        for (const mutation of mutations) {
+          if (mutation.removedNodes.length > 0) focus(container);
+        }
       };
-      document.addEventListener("focusin", s), document.addEventListener("focusout", l);
-      const m = new MutationObserver(r);
-      return o && m.observe(o, { childList: !0, subtree: !0 }), () => {
-        document.removeEventListener("focusin", s), document.removeEventListener("focusout", l), m.disconnect();
+      document.addEventListener("focusin", handleFocusIn2);
+      document.addEventListener("focusout", handleFocusOut2);
+      const mutationObserver = new MutationObserver(handleMutations2);
+      if (container) mutationObserver.observe(container, { childList: true, subtree: true });
+      return () => {
+        document.removeEventListener("focusin", handleFocusIn2);
+        document.removeEventListener("focusout", handleFocusOut2);
+        mutationObserver.disconnect();
       };
     }
-  }, [u, o, a.paused]), d.useEffect(() => {
-    if (o) {
-      S.add(a);
-      const s = document.activeElement;
-      if (!o.contains(s)) {
-        const r = new CustomEvent(F, N);
-        o.addEventListener(F, E), o.dispatchEvent(r), r.defaultPrevented || (w(W(I(o)), { select: !0 }), document.activeElement === s && f(o));
+  }, [trapped, container, focusScope.paused]);
+  React.useEffect(() => {
+    if (container) {
+      focusScopesStack.add(focusScope);
+      const previouslyFocusedElement = document.activeElement;
+      const hasFocusedCandidate = container.contains(previouslyFocusedElement);
+      if (!hasFocusedCandidate) {
+        const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
+        container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+        container.dispatchEvent(mountEvent);
+        if (!mountEvent.defaultPrevented) {
+          focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
+          if (document.activeElement === previouslyFocusedElement) {
+            focus(container);
+          }
+        }
       }
       return () => {
-        o.removeEventListener(F, E), setTimeout(() => {
-          const r = new CustomEvent(T, N);
-          o.addEventListener(T, v), o.dispatchEvent(r), r.defaultPrevented || f(s ?? document.body, { select: !0 }), o.removeEventListener(T, v), S.remove(a);
+        container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+        setTimeout(() => {
+          const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
+          container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+          container.dispatchEvent(unmountEvent);
+          if (!unmountEvent.defaultPrevented) {
+            focus(previouslyFocusedElement ?? document.body, { select: true });
+          }
+          container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+          focusScopesStack.remove(focusScope);
         }, 0);
       };
     }
-  }, [o, E, v, a]);
-  const P = d.useCallback(
-    (s) => {
-      if (!t && !u || a.paused) return;
-      const l = s.key === "Tab" && !s.altKey && !s.ctrlKey && !s.metaKey, r = document.activeElement;
-      if (l && r) {
-        const m = s.currentTarget, [i, c] = x(m);
-        i && c ? !s.shiftKey && r === c ? (s.preventDefault(), t && f(i, { select: !0 })) : s.shiftKey && r === i && (s.preventDefault(), t && f(c, { select: !0 })) : r === m && s.preventDefault();
+  }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);
+  const handleKeyDown = React.useCallback(
+    (event) => {
+      if (!loop && !trapped) return;
+      if (focusScope.paused) return;
+      const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+      const focusedElement = document.activeElement;
+      if (isTabKey && focusedElement) {
+        const container2 = event.currentTarget;
+        const [first, last] = getTabbableEdges(container2);
+        const hasTabbableElementsInside = first && last;
+        if (!hasTabbableElementsInside) {
+          if (focusedElement === container2) event.preventDefault();
+        } else {
+          if (!event.shiftKey && focusedElement === last) {
+            event.preventDefault();
+            if (loop) focus(first, { select: true });
+          } else if (event.shiftKey && focusedElement === first) {
+            event.preventDefault();
+            if (loop) focus(last, { select: true });
+          }
+        }
       }
     },
-    [t, u, a.paused]
+    [loop, trapped, focusScope.paused]
   );
-  return /* @__PURE__ */ _(M.div, { tabIndex: -1, ...g, ref: A, onKeyDown: P });
+  return /* @__PURE__ */ jsx(Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown });
 });
-k.displayName = K;
-function w(e, { select: n = !1 } = {}) {
-  const t = document.activeElement;
-  for (const u of e)
-    if (f(u, { select: n }), document.activeElement !== t) return;
+FocusScope.displayName = FOCUS_SCOPE_NAME;
+function focusFirst(candidates, { select = false } = {}) {
+  const previouslyFocusedElement = document.activeElement;
+  for (const candidate of candidates) {
+    focus(candidate, { select });
+    if (document.activeElement !== previouslyFocusedElement) return;
+  }
 }
-function x(e) {
-  const n = I(e), t = O(n, e), u = O(n.reverse(), e);
-  return [t, u];
+function getTabbableEdges(container) {
+  const candidates = getTabbableCandidates(container);
+  const first = findVisible(candidates, container);
+  const last = findVisible(candidates.reverse(), container);
+  return [first, last];
 }
-function I(e) {
-  const n = [], t = document.createTreeWalker(e, NodeFilter.SHOW_ELEMENT, {
-    acceptNode: (u) => {
-      const p = u.tagName === "INPUT" && u.type === "hidden";
-      return u.disabled || u.hidden || p ? NodeFilter.FILTER_SKIP : u.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+function getTabbableCandidates(container) {
+  const nodes = [];
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (node) => {
+      const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
+      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
     }
   });
-  for (; t.nextNode(); ) n.push(t.currentNode);
-  return n;
+  while (walker.nextNode()) nodes.push(walker.currentNode);
+  return nodes;
 }
-function O(e, n) {
-  for (const t of e)
-    if (!D(t, { upTo: n })) return t;
+function findVisible(elements, container) {
+  for (const element of elements) {
+    if (!isHidden(element, { upTo: container })) return element;
+  }
 }
-function D(e, { upTo: n }) {
-  if (getComputedStyle(e).visibility === "hidden") return !0;
-  for (; e; ) {
-    if (n !== void 0 && e === n) return !1;
-    if (getComputedStyle(e).display === "none") return !0;
-    e = e.parentElement;
+function isHidden(node, { upTo }) {
+  if (getComputedStyle(node).visibility === "hidden") return true;
+  while (node) {
+    if (upTo !== void 0 && node === upTo) return false;
+    if (getComputedStyle(node).display === "none") return true;
+    node = node.parentElement;
   }
-  return !1;
+  return false;
 }
-function H(e) {
-  return e instanceof HTMLInputElement && "select" in e;
+function isSelectableInput(element) {
+  return element instanceof HTMLInputElement && "select" in element;
 }
-function f(e, { select: n = !1 } = {}) {
-  if (e && e.focus) {
-    const t = document.activeElement;
-    e.focus({ preventScroll: !0 }), e !== t && H(e) && n && e.select();
+function focus(element, { select = false } = {}) {
+  if (element && element.focus) {
+    const previouslyFocusedElement = document.activeElement;
+    element.focus({ preventScroll: true });
+    if (element !== previouslyFocusedElement && isSelectableInput(element) && select)
+      element.select();
   }
 }
-var S = V();
-function V() {
-  let e = [];
+var focusScopesStack = createFocusScopesStack();
+function createFocusScopesStack() {
+  let stack = [];
   return {
-    add(n) {
-      const t = e[0];
-      n !== t && (t == null || t.pause()), e = C(e, n), e.unshift(n);
+    add(focusScope) {
+      const activeFocusScope = stack[0];
+      if (focusScope !== activeFocusScope) {
+        activeFocusScope == null ? void 0 : activeFocusScope.pause();
+      }
+      stack = arrayRemove(stack, focusScope);
+      stack.unshift(focusScope);
     },
-    remove(n) {
-      var t;
-      e = C(e, n), (t = e[0]) == null || t.resume();
+    remove(focusScope) {
+      var _a;
+      stack = arrayRemove(stack, focusScope);
+      (_a = stack[0]) == null ? void 0 : _a.resume();
     }
   };
 }
-function C(e, n) {
-  const t = [...e], u = t.indexOf(n);
-  return u !== -1 && t.splice(u, 1), t;
+function arrayRemove(array, item) {
+  const updatedArray = [...array];
+  const index = updatedArray.indexOf(item);
+  if (index !== -1) {
+    updatedArray.splice(index, 1);
+  }
+  return updatedArray;
 }
-function W(e) {
-  return e.filter((n) => n.tagName !== "A");
+function removeLinks(items) {
+  return items.filter((item) => item.tagName !== "A");
 }
 export {
-  k as FocusScope
+  FocusScope
 };