@tamagui/focus-scope 2.0.0-rc.4 → 2.0.0-rc.40

package/dist/cjs/FocusScope.cjs

@@ -2,75 +2,80 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-    value: mod,
-    enumerable: !0
-  }) : target, mod)),
-  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-    value: !0
-  }), mod);
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
 var FocusScope_exports = {};
 __export(FocusScope_exports, {
   FocusScope: () => FocusScope,
   useFocusScope: () => useFocusScope
 });
 module.exports = __toCommonJS(FocusScope_exports);
-var import_compose_refs = require("@tamagui/compose-refs"),
-  import_constants = require("@tamagui/constants"),
-  import_use_async = require("@tamagui/use-async"),
-  import_use_event = require("@tamagui/use-event"),
-  React = __toESM(require("react"), 1),
-  import_FocusScopeController = require("./FocusScopeController.cjs"),
-  import_jsx_runtime = require("react/jsx-runtime");
-const AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount",
-  AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount",
-  EVENT_OPTIONS = {
-    bubbles: !1,
-    cancelable: !0
-  },
-  FocusScope = React.forwardRef(function ({
-    __scopeFocusScope,
-    ...props
-  }, forwardedRef) {
-    const context = (0, import_FocusScopeController.useFocusScopeControllerContext)("FocusScope", __scopeFocusScope, {
-        warn: !1,
-        fallback: {}
-      }),
-      mergedProps = {
-        ...props,
-        enabled: context.enabled ?? props.enabled,
-        loop: context.loop ?? props.loop,
-        trapped: context.trapped ?? props.trapped,
-        onMountAutoFocus: context.onMountAutoFocus ?? props.onMountAutoFocus,
-        onUnmountAutoFocus: context.onUnmountAutoFocus ?? props.onUnmountAutoFocus,
-        forceUnmount: context.forceUnmount ?? props.forceUnmount,
-        focusOnIdle: context.focusOnIdle ?? props.focusOnIdle
-      },
-      childProps = useFocusScope(mergedProps, forwardedRef);
-    return typeof mergedProps.children == "function" ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
-      children: mergedProps.children(childProps)
-    }) : React.cloneElement(React.Children.only(mergedProps.children), childProps);
+var import_compose_refs = require("@tamagui/compose-refs");
+var import_constants = require("@tamagui/constants");
+var import_use_async = require("@tamagui/use-async");
+var import_use_event = require("@tamagui/use-event");
+var React = __toESM(require("react"), 1);
+var import_FocusScopeController = require("./FocusScopeController.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+const AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
+const AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
+const EVENT_OPTIONS = {
+  bubbles: false,
+  cancelable: true
+};
+const FocusScope = React.forwardRef(function FocusScope2({
+  __scopeFocusScope,
+  ...props
+}, forwardedRef) {
+  const context = (0, import_FocusScopeController.useFocusScopeControllerContext)("FocusScope", __scopeFocusScope, {
+    warn: false,
+    fallback: {}
   });
+  const mergedProps = {
+    ...props,
+    enabled: context.enabled ?? props.enabled,
+    loop: context.loop ?? props.loop,
+    trapped: context.trapped ?? props.trapped,
+    onMountAutoFocus: context.onMountAutoFocus ?? props.onMountAutoFocus,
+    onUnmountAutoFocus: context.onUnmountAutoFocus ?? props.onUnmountAutoFocus,
+    forceUnmount: context.forceUnmount ?? props.forceUnmount,
+    focusOnIdle: context.focusOnIdle ?? props.focusOnIdle
+  };
+  const childProps = useFocusScope(mergedProps, forwardedRef);
+  if (typeof mergedProps.children === "function") {
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, {
+      children: mergedProps.children(childProps)
+    });
+  }
+  return React.cloneElement(React.Children.only(mergedProps.children), childProps);
+});
 function setupFocusTrap(container, lastFocusedElementRef, focusScope) {
   const controller = new AbortController();
   let rafId = null;
@@ -78,118 +83,215 @@ function setupFocusTrap(container, lastFocusedElementRef, focusScope) {
     if (rafId) return;
     const elementToFocus = lastFocusedElementRef.current;
     rafId = requestAnimationFrame(() => {
-      rafId = null, !focusScope.paused && (focusScope.stopped || container.isConnected && (container.contains(document.activeElement) || focus(elementToFocus)));
+      rafId = null;
+      if (focusScope.paused) return;
+      if (focusScope.stopped) return;
+      if (!container.isConnected) return;
+      if (!container.contains(document.activeElement)) {
+        focus(elementToFocus);
+      }
     });
   }
   function handleFocusIn(event) {
     if (focusScope.paused) return;
     const target = event.target;
-    container.contains(target) ? (target?.addEventListener("blur", handleBlur, {
-      signal: controller.signal
-    }), lastFocusedElementRef.current = target) : scheduleRefocus();
+    if (container.contains(target)) {
+      target?.addEventListener("blur", handleBlur, {
+        signal: controller.signal
+      });
+      lastFocusedElementRef.current = target;
+    } else {
+      scheduleRefocus();
+    }
   }
   function handleFocusOut(event) {
-    controller.abort(), !focusScope.paused && (container.contains(event.relatedTarget) || scheduleRefocus());
+    controller.abort();
+    if (focusScope.paused) return;
+    if (!container.contains(event.relatedTarget)) {
+      scheduleRefocus();
+    }
   }
   function handleBlur() {}
-  return document.addEventListener("focusin", handleFocusIn), document.addEventListener("focusout", handleFocusOut), () => {
-    rafId && (cancelAnimationFrame(rafId), rafId = null), controller.abort(), document.removeEventListener("focusin", handleFocusIn), document.removeEventListener("focusout", handleFocusOut);
+  document.addEventListener("focusin", handleFocusIn);
+  document.addEventListener("focusout", handleFocusOut);
+  return () => {
+    if (rafId) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+    controller.abort();
+    document.removeEventListener("focusin", handleFocusIn);
+    document.removeEventListener("focusout", handleFocusOut);
   };
 }
 function useFocusScope(props, forwardedRef) {
   const {
-      loop = !1,
-      enabled = !0,
-      trapped = !1,
-      onMountAutoFocus: onMountAutoFocusProp,
-      onUnmountAutoFocus: onUnmountAutoFocusProp,
-      forceUnmount,
-      focusOnIdle = !0,
-      children,
-      ...scopeProps
-    } = props,
-    [container, setContainer] = React.useState(null),
-    containerRef = React.useRef(null),
-    onMountAutoFocus = (0, import_use_event.useEvent)(onMountAutoFocusProp),
-    onUnmountAutoFocus = (0, import_use_event.useEvent)(onUnmountAutoFocusProp),
-    lastFocusedElementRef = React.useRef(null),
-    focusScopeRef = React.useRef({
-      paused: !1,
-      stopped: !1,
-      // set to true when cleanup starts, signals trap to stop
-      pause() {
-        this.paused = !0;
-      },
-      resume() {
-        this.paused = !1;
-      },
-      stop() {
-        this.stopped = !0;
+    loop = false,
+    enabled = true,
+    trapped = false,
+    onMountAutoFocus: onMountAutoFocusProp,
+    onUnmountAutoFocus: onUnmountAutoFocusProp,
+    forceUnmount,
+    focusOnIdle = true,
+    children,
+    ...scopeProps
+  } = props;
+  const [container, setContainer] = React.useState(null);
+  const containerRef = React.useRef(null);
+  const onMountAutoFocus = (0, import_use_event.useEvent)(onMountAutoFocusProp);
+  const onUnmountAutoFocus = (0, import_use_event.useEvent)(onUnmountAutoFocusProp);
+  const lastFocusedElementRef = React.useRef(null);
+  const focusScopeRef = React.useRef({
+    paused: false,
+    stopped: false,
+    // set to true when cleanup starts, signals trap to stop
+    pause() {
+      this.paused = true;
+    },
+    resume() {
+      this.paused = false;
+    },
+    stop() {
+      this.stopped = true;
+    }
+  });
+  const focusScope = focusScopeRef.current;
+  const trapCleanupRef = React.useRef(null);
+  const setContainerRef = React.useCallback(node => {
+    if (trapCleanupRef.current) {
+      trapCleanupRef.current();
+      trapCleanupRef.current = null;
+    }
+    containerRef.current = node;
+    if (import_constants.isWeb && node && enabled && trapped) {
+      trapCleanupRef.current = setupFocusTrap(node, lastFocusedElementRef, focusScopeRef.current);
+    }
+    setContainer(node);
+  }, [enabled, trapped]);
+  const composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, setContainerRef);
+  (0, import_constants.useIsomorphicLayoutEffect)(() => {
+    if (!trapped) {
+      focusScope.stopped = true;
+      if (trapCleanupRef.current) {
+        trapCleanupRef.current();
+        trapCleanupRef.current = null;
       }
-    }),
-    focusScope = focusScopeRef.current,
-    trapCleanupRef = React.useRef(null),
-    setContainerRef = React.useCallback(node => {
-      trapCleanupRef.current && (trapCleanupRef.current(), trapCleanupRef.current = null), containerRef.current = node, import_constants.isWeb && node && enabled && trapped && (trapCleanupRef.current = setupFocusTrap(node, lastFocusedElementRef, focusScopeRef.current)), setContainer(node);
-    }, [enabled, trapped]),
-    composedRefs = (0, import_compose_refs.useComposedRefs)(forwardedRef, setContainerRef);
-  (0, import_constants.useIsomorphicLayoutEffect)(() => () => {
-    trapCleanupRef.current && (trapCleanupRef.current(), trapCleanupRef.current = null);
-  }, []), (0, import_use_async.useAsyncEffect)(async signal => {
-    if (!enabled || !container || forceUnmount) return;
-    focusScope.stopped = !1, focusScopesStack.add(focusScope);
+    }
+    return () => {
+      if (trapCleanupRef.current) {
+        trapCleanupRef.current();
+        trapCleanupRef.current = null;
+      }
+    };
+  }, [trapped, focusScope]);
+  (0, import_use_async.useAsyncEffect)(async signal => {
+    if (!enabled) return;
+    if (!container) return;
+    if (forceUnmount) return;
+    if (trapped) {
+      focusScope.stopped = false;
+    }
+    focusScopesStack.add(focusScope);
     const previouslyFocusedElement = document.activeElement;
-    if (!container.contains(previouslyFocusedElement)) {
+    const hasFocusedCandidate = container.contains(previouslyFocusedElement) && previouslyFocusedElement !== null && !isHidden(previouslyFocusedElement, {
+      upTo: container
+    });
+    if (!hasFocusedCandidate) {
       const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
-      if (container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus), container.dispatchEvent(mountEvent), !mountEvent.defaultPrevented) {
-        focusOnIdle && (await (0, import_use_async.idle)(signal, typeof focusOnIdle == "object" ? focusOnIdle : {
-          // we can't wait too long or else user can take an action and then we focus
-          max: 200,
-          min: typeof focusOnIdle == "number" ? focusOnIdle : 16
+      container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+      container.dispatchEvent(mountEvent);
+      if (!mountEvent.defaultPrevented) {
+        if (focusOnIdle) {
+          await (0, import_use_async.idle)(signal, typeof focusOnIdle == "object" ? focusOnIdle : {
+            // we can't wait too long or else user can take an action and then we focus
+            max: 200,
+            min: typeof focusOnIdle == "number" ? focusOnIdle : 16
+          });
+        }
+        const allCandidates = getTabbableCandidates(container);
+        const linkedRemoved = removeLinks(allCandidates);
+        const visibleCandidates = linkedRemoved.filter(candidate => !isHidden(candidate, {
+          upTo: container
         }));
-        const allCandidates = getTabbableCandidates(container),
-          visibleCandidates = removeLinks(allCandidates).filter(candidate => !isHidden(candidate, {
-            upTo: container
-          }));
         focusFirst(visibleCandidates, {
-          select: !0
-        }), visibleCandidates.length > 0 ? lastFocusedElementRef.current = visibleCandidates[0] : lastFocusedElementRef.current = container, document.activeElement === previouslyFocusedElement && visibleCandidates.length === 0 && focus(container);
+          select: true
+        });
+        if (visibleCandidates.length > 0) {
+          lastFocusedElementRef.current = visibleCandidates[0];
+        } else {
+          lastFocusedElementRef.current = container;
+        }
+        if (document.activeElement === previouslyFocusedElement && visibleCandidates.length === 0) {
+          focus(container);
+        }
       }
     }
     return () => {
-      focusScope.stop(), container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
+      focusScope.stop();
+      container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
       const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
-      container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus), container.dispatchEvent(unmountEvent), unmountEvent.defaultPrevented || focus(previouslyFocusedElement ?? document.body, {
-        select: !0
-      }), container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus), focusScopesStack.remove(focusScope);
+      container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+      container.dispatchEvent(unmountEvent);
+      if (!unmountEvent.defaultPrevented) {
+        const currentFocus = document.activeElement;
+        const focusHasMovedOutside = currentFocus && currentFocus !== document.body && currentFocus !== container && !container.contains(currentFocus);
+        if (!focusHasMovedOutside) {
+          focus(previouslyFocusedElement ?? document.body, {
+            select: true
+          });
+        }
+      }
+      container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
+      focusScopesStack.remove(focusScope);
     };
   }, [enabled, container, forceUnmount, onMountAutoFocus, onUnmountAutoFocus, focusScope, focusOnIdle]);
   const handleKeyDown = React.useCallback(event => {
-    if (!trapped || !loop || focusScope.paused || !enabled || !container) return;
-    const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey,
-      focusedElement = document.activeElement;
+    if (!trapped) return;
+    if (!loop) return;
+    if (focusScope.paused) return;
+    if (!enabled) return;
+    if (!container) return;
+    const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
+    const focusedElement = document.activeElement;
     if (isTabKey && focusedElement) {
       const [first, last] = getTabbableEdges(container);
-      first && last ? !event.shiftKey && focusedElement === last ? (event.preventDefault(), loop && focus(first, {
-        select: !0
-      })) : event.shiftKey && focusedElement === first && (event.preventDefault(), loop && focus(last, {
-        select: !0
-      })) : focusedElement === container && event.preventDefault();
+      const hasTabbableElementsInside = first && last;
+      if (!hasTabbableElementsInside) {
+        if (focusedElement === container) 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
+          });
+        }
+      }
     }
   }, [loop, trapped, focusScope.paused, enabled, container]);
   React.useEffect(() => {
-    if (!container || !trapped || !loop || !enabled) return;
+    if (!container) return;
+    if (!trapped) return;
+    if (!loop) return;
+    if (!enabled) return;
     const handleKeyDownCapture = event => {
-      event.key === "Tab" && handleKeyDown(event);
+      if (event.key === "Tab") {
+        handleKeyDown(event);
+      }
     };
-    return container.addEventListener("keydown", handleKeyDownCapture, !0), () => {
-      container.removeEventListener("keydown", handleKeyDownCapture, !0);
+    container.addEventListener("keydown", handleKeyDownCapture, true);
+    return () => {
+      container.removeEventListener("keydown", handleKeyDownCapture, true);
     };
   }, [container, trapped, loop, enabled, handleKeyDown]);
-  const existingOnKeyDown = scopeProps.onKeyDown,
-    composedOnKeyDown = React.useCallback(event => {
-      existingOnKeyDown?.(event);
-    }, [existingOnKeyDown]);
+  const existingOnKeyDown = scopeProps.onKeyDown;
+  const composedOnKeyDown = React.useCallback(event => {
+    existingOnKeyDown?.(event);
+  }, [existingOnKeyDown]);
   return {
     ...scopeProps,
     ref: composedRefs,
@@ -197,59 +299,66 @@ function useFocusScope(props, forwardedRef) {
   };
 }
 function focusFirst(candidates, {
-  select = !1
+  select = false
 } = {}) {
   const previouslyFocusedElement = document.activeElement;
-  for (const candidate of candidates) if (focus(candidate, {
-    select
-  }), document.activeElement !== previouslyFocusedElement) return;
+  for (const candidate of candidates) {
+    focus(candidate, {
+      select
+    });
+    if (document.activeElement !== previouslyFocusedElement) return;
+  }
 }
 function getTabbableEdges(container) {
-  const candidates = getTabbableCandidates(container),
-    first = findVisible(candidates, container),
-    last = findVisible(candidates.reverse(), container);
+  const candidates = getTabbableCandidates(container);
+  const first = findVisible(candidates, container);
+  const last = findVisible(candidates.reverse(), container);
   return [first, last];
 }
 function getTabbableCandidates(container) {
-  const nodes = [],
-    walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
-      acceptNode: node => {
-        const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
-        return node.disabled || node.hidden || isHiddenInput ? NodeFilter.FILTER_SKIP : node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-      }
-    });
-  for (; walker.nextNode();) nodes.push(walker.currentNode);
+  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;
+    }
+  });
+  while (walker.nextNode()) nodes.push(walker.currentNode);
   return nodes;
 }
 function findVisible(elements, container) {
-  for (const element of elements) if (!isHidden(element, {
-    upTo: container
-  })) return element;
+  for (const element of elements) {
+    if (!isHidden(element, {
+      upTo: container
+    })) return element;
+  }
 }
 function isHidden(node, {
   upTo
 }) {
-  if (getComputedStyle(node).visibility === "hidden") return !0;
-  for (; node;) {
-    if (upTo !== void 0 && node === upTo) return !1;
-    if (getComputedStyle(node).display === "none") return !0;
+  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 isSelectableInput(element) {
   return element instanceof HTMLInputElement && "select" in element;
 }
 function focus(element, {
-  select = !1
+  select = false
 } = {}) {
   if (element?.focus) {
     const previouslyFocusedElement = document.activeElement;
     try {
       element.focus({
-        preventScroll: !0
-      }), element !== previouslyFocusedElement && isSelectableInput(element) && select && element.select();
-    } catch {}
+        preventScroll: true
+      });
+      if (element !== previouslyFocusedElement && isSelectableInput(element) && select) element.select();
+    } catch (error) {}
   }
 }
 const focusScopesStack = createFocusScopesStack();
@@ -258,17 +367,25 @@ function createFocusScopesStack() {
   return {
     add(focusScope) {
       const activeFocusScope = stack[0];
-      focusScope !== activeFocusScope && activeFocusScope?.pause(), stack = arrayRemove(stack, focusScope), stack.unshift(focusScope);
+      if (focusScope !== activeFocusScope) {
+        activeFocusScope?.pause();
+      }
+      stack = arrayRemove(stack, focusScope);
+      stack.unshift(focusScope);
     },
     remove(focusScope) {
-      stack = arrayRemove(stack, focusScope), stack[0]?.resume();
+      stack = arrayRemove(stack, focusScope);
+      stack[0]?.resume();
     }
   };
 }
 function arrayRemove(array, item) {
-  const updatedArray = [...array],
-    index = updatedArray.indexOf(item);
-  return index !== -1 && updatedArray.splice(index, 1), updatedArray;
+  const updatedArray = [...array];
+  const index = updatedArray.indexOf(item);
+  if (index !== -1) {
+    updatedArray.splice(index, 1);
+  }
+  return updatedArray;
 }
 function removeLinks(items) {
   return items.filter(item => item.tagName !== "A");

package/dist/cjs/FocusScope.native.js

@@ -4,40 +4,42 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-    value: mod,
-    enumerable: !0
-  }) : target, mod)),
-  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-    value: !0
-  }), mod);
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
 var FocusScope_native_exports = {};
 __export(FocusScope_native_exports, {
   FocusScope: () => FocusScope
 });
 module.exports = __toCommonJS(FocusScope_native_exports);
-var import_react = __toESM(require("react"), 1),
-  FocusScope = /* @__PURE__ */import_react.default.forwardRef(function (props, _ref) {
-    return props.children;
-  });
+var import_react = __toESM(require("react"), 1);
+var FocusScope = /* @__PURE__ */import_react.default.forwardRef(function (props, _ref) {
+  return props.children;
+});
 //# sourceMappingURL=FocusScope.native.js.map

package/dist/cjs/FocusScope.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["FocusScope_native_exports","__export","FocusScope","module","exports","__toCommonJS","import_react","__toESM","require","default","forwardRef","props","_ref","children"],"sources":["../../src/FocusScope.native.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,yBAAA;AAAAC,QAAA,CAAAD,yBAAA;EAAAE,UAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAC,YAAA,CAAAL,yBAAA;AAAA,IAAAM,YAAA,GAAkBC,OAAA,CAAAC,OAAA;EACPN,UAAA,GAA2B,eAAAI,YAAA,CAAAG,OAAA,CAAMC,UAAA,CAAW,UAASC,KAAA,EAAOC,IAAA,EAAM;IACzE,OAAOD,KAAA,CAAME,QAAA;EACjB,CAAC","ignoreList":[]}
+{"version":3,"names":["FocusScope_native_exports","__export","FocusScope","module","exports","__toCommonJS","import_react","__toESM","require","default","forwardRef","props","_ref","children"],"sources":["../../src/FocusScope.native.tsx"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,yBAAA;AAAAC,QAAA,CAAAD,yBAAA;EAAAE,UAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAC,YAAA,CAAAL,yBAAA;AAAA,IAAAM,YAAA,GAAkBC,OAAA,CAAAC,OAAA;AACX,IAAIN,UAAA,GAA2B,eAAAI,YAAA,CAAAG,OAAA,CAAMC,UAAA,CAAW,UAASC,KAAA,EAAOC,IAAA,EAAM;EACzE,OAAOD,KAAA,CAAME,QAAA;AACjB,CAAC","ignoreList":[]}