@easypost/easy-ui 1.0.0-alpha.6 → 1.0.0-alpha.61

package/__chunks__/useResizeObserver-BsbT3mjh.js

@@ -0,0 +1,34 @@
+"use strict";
+const React = require("react");
+function $9daab02d461809db$var$hasResizeObserver() {
+  return typeof window.ResizeObserver !== "undefined";
+}
+function $9daab02d461809db$export$683480f191c0e3ea(options) {
+  const { ref, box, onResize } = options;
+  React.useEffect(() => {
+    let element = ref === null || ref === void 0 ? void 0 : ref.current;
+    if (!element) return;
+    if (!$9daab02d461809db$var$hasResizeObserver()) {
+      window.addEventListener("resize", onResize, false);
+      return () => {
+        window.removeEventListener("resize", onResize, false);
+      };
+    } else {
+      const resizeObserverInstance = new window.ResizeObserver((entries) => {
+        if (!entries.length) return;
+        onResize();
+      });
+      resizeObserverInstance.observe(element, {
+        box
+      });
+      return () => {
+        if (element) resizeObserverInstance.unobserve(element);
+      };
+    }
+  }, [
+    onResize,
+    ref,
+    box
+  ]);
+}
+exports.$9daab02d461809db$export$683480f191c0e3ea = $9daab02d461809db$export$683480f191c0e3ea;

package/__chunks__/useResizeObserver-Dyb4wvuA.mjs

@@ -0,0 +1,35 @@
+import { useEffect } from "react";
+function $9daab02d461809db$var$hasResizeObserver() {
+  return typeof window.ResizeObserver !== "undefined";
+}
+function $9daab02d461809db$export$683480f191c0e3ea(options) {
+  const { ref, box, onResize } = options;
+  useEffect(() => {
+    let element = ref === null || ref === void 0 ? void 0 : ref.current;
+    if (!element) return;
+    if (!$9daab02d461809db$var$hasResizeObserver()) {
+      window.addEventListener("resize", onResize, false);
+      return () => {
+        window.removeEventListener("resize", onResize, false);
+      };
+    } else {
+      const resizeObserverInstance = new window.ResizeObserver((entries) => {
+        if (!entries.length) return;
+        onResize();
+      });
+      resizeObserverInstance.observe(element, {
+        box
+      });
+      return () => {
+        if (element) resizeObserverInstance.unobserve(element);
+      };
+    }
+  }, [
+    onResize,
+    ref,
+    box
+  ]);
+}
+export {
+  $9daab02d461809db$export$683480f191c0e3ea as $
+};

package/__chunks__/useSelectableItem-BGvBbIwY.js

@@ -0,0 +1,538 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const React = require("react");
+const ReactDOM = require("react-dom");
+const FocusScope = require("./FocusScope-Co1hHX8R.js");
+const focusSafely = require("./focusSafely-sLifanM7.js");
+const mergeProps = require("./mergeProps-DniMwM6P.js");
+const context$1 = require("./context-C6CFGY_J.js");
+const usePress = require("./usePress-Dz8YYpge.js");
+const useEvent = require("./useEvent-DY7dR7Mi.js");
+const scrollIntoView = require("./scrollIntoView-DkcUbB3D.js");
+const useFocusVisible = require("./useFocusVisible-PBQuklI8.js");
+const context = require("./context-D3NeXov7.js");
+const isVirtualEvent = require("./isVirtualEvent-DwoP1rNI.js");
+const $8a26561d2877236e$var$DEFAULT_THRESHOLD = 500;
+function $8a26561d2877236e$export$c24ed0104d07eab9(props) {
+  let { isDisabled, onLongPressStart, onLongPressEnd, onLongPress, threshold = $8a26561d2877236e$var$DEFAULT_THRESHOLD, accessibilityDescription } = props;
+  const timeRef = React.useRef(void 0);
+  let { addGlobalListener, removeGlobalListener } = usePress.$03deb23ff14920c4$export$4eaf04e54aa8eed6();
+  let { pressProps } = usePress.$f6c31cce2adf654f$export$45712eceda6fad21({
+    isDisabled,
+    onPressStart(e) {
+      e.continuePropagation();
+      if (e.pointerType === "mouse" || e.pointerType === "touch") {
+        if (onLongPressStart) onLongPressStart(__spreadProps(__spreadValues({}, e), {
+          type: "longpressstart"
+        }));
+        timeRef.current = setTimeout(() => {
+          e.target.dispatchEvent(new PointerEvent("pointercancel", {
+            bubbles: true
+          }));
+          if (onLongPress) onLongPress(__spreadProps(__spreadValues({}, e), {
+            type: "longpress"
+          }));
+          timeRef.current = void 0;
+        }, threshold);
+        if (e.pointerType === "touch") {
+          let onContextMenu = (e2) => {
+            e2.preventDefault();
+          };
+          addGlobalListener(e.target, "contextmenu", onContextMenu, {
+            once: true
+          });
+          addGlobalListener(window, "pointerup", () => {
+            setTimeout(() => {
+              removeGlobalListener(e.target, "contextmenu", onContextMenu);
+            }, 30);
+          }, {
+            once: true
+          });
+        }
+      }
+    },
+    onPressEnd(e) {
+      if (timeRef.current) clearTimeout(timeRef.current);
+      if (onLongPressEnd && (e.pointerType === "mouse" || e.pointerType === "touch")) onLongPressEnd(__spreadProps(__spreadValues({}, e), {
+        type: "longpressend"
+      }));
+    }
+  });
+  let descriptionProps = scrollIntoView.$ef06256079686ba0$export$f8aeda7b10753fa1(onLongPress && !isDisabled ? accessibilityDescription : void 0);
+  return {
+    longPressProps: mergeProps.$3ef42575df84b30b$export$9d1611c77c2fe928(pressProps, descriptionProps)
+  };
+}
+function $feb5ffebff200149$export$d3e3bd3e26688c04(e) {
+  return isVirtualEvent.$c87311424ea30a05$export$e1865c3bedcd822b() ? e.altKey : e.ctrlKey;
+}
+function $feb5ffebff200149$export$16792effe837dba3(e) {
+  if (isVirtualEvent.$c87311424ea30a05$export$9ac100e40613ea10()) return e.metaKey;
+  return e.ctrlKey;
+}
+const $fb3050f43d946246$var$TYPEAHEAD_DEBOUNCE_WAIT_MS = 1e3;
+function $fb3050f43d946246$export$e32c88dfddc6e1d8(options) {
+  let { keyboardDelegate, selectionManager, onTypeSelect } = options;
+  let state = React.useRef({
+    search: "",
+    timeout: void 0
+  }).current;
+  let onKeyDown = (e) => {
+    let character = $fb3050f43d946246$var$getStringForKey(e.key);
+    if (!character || e.ctrlKey || e.metaKey || !e.currentTarget.contains(e.target)) return;
+    if (character === " " && state.search.trim().length > 0) {
+      e.preventDefault();
+      if (!("continuePropagation" in e)) e.stopPropagation();
+    }
+    state.search += character;
+    if (keyboardDelegate.getKeyForSearch != null) {
+      let key = keyboardDelegate.getKeyForSearch(state.search, selectionManager.focusedKey);
+      if (key == null) key = keyboardDelegate.getKeyForSearch(state.search);
+      if (key != null) {
+        selectionManager.setFocusedKey(key);
+        if (onTypeSelect) onTypeSelect(key);
+      }
+    }
+    clearTimeout(state.timeout);
+    state.timeout = setTimeout(() => {
+      state.search = "";
+    }, $fb3050f43d946246$var$TYPEAHEAD_DEBOUNCE_WAIT_MS);
+  };
+  return {
+    typeSelectProps: {
+      // Using a capturing listener to catch the keydown event before
+      // other hooks in order to handle the Spacebar event.
+      onKeyDownCapture: keyboardDelegate.getKeyForSearch ? onKeyDown : void 0
+    }
+  };
+}
+function $fb3050f43d946246$var$getStringForKey(key) {
+  if (key.length === 1 || !/^[A-Z]/i.test(key)) return key;
+  return "";
+}
+function $ae20dd8cbca75726$export$d6daf82dcd84e87c(options) {
+  let { selectionManager: manager, keyboardDelegate: delegate, ref, autoFocus = false, shouldFocusWrap = false, disallowEmptySelection = false, disallowSelectAll = false, selectOnFocus = manager.selectionBehavior === "replace", disallowTypeAhead = false, shouldUseVirtualFocus, allowsTabNavigation = false, isVirtualized, scrollRef = ref, linkBehavior = "action" } = options;
+  let { direction } = context.$18f2051aff69b9bf$export$43bb16f9c6d9e3f7();
+  let router = usePress.$ea8dcbcb9ea1b556$export$9a302a45f65d0572();
+  let onKeyDown = (e) => {
+    var _ref_current;
+    if (e.altKey && e.key === "Tab") e.preventDefault();
+    if (!((_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.contains(e.target))) return;
+    const navigateToKey = (key, childFocus) => {
+      if (key != null) {
+        if (manager.isLink(key) && linkBehavior === "selection" && selectOnFocus && !$feb5ffebff200149$export$d3e3bd3e26688c04(e)) {
+          var _scrollRef_current;
+          ReactDOM.flushSync(() => {
+            manager.setFocusedKey(key, childFocus);
+          });
+          let item = (_scrollRef_current = scrollRef.current) === null || _scrollRef_current === void 0 ? void 0 : _scrollRef_current.querySelector(`[data-key="${CSS.escape(key.toString())}"]`);
+          let itemProps = manager.getItemProps(key);
+          if (item) router.open(item, e, itemProps.href, itemProps.routerOptions);
+          return;
+        }
+        manager.setFocusedKey(key, childFocus);
+        if (manager.isLink(key) && linkBehavior === "override") return;
+        if (e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(key);
+        else if (selectOnFocus && !$feb5ffebff200149$export$d3e3bd3e26688c04(e)) manager.replaceSelection(key);
+      }
+    };
+    switch (e.key) {
+      case "ArrowDown":
+        if (delegate.getKeyBelow) {
+          var _delegate_getKeyBelow, _delegate_getFirstKey, _delegate_getFirstKey1;
+          let nextKey = manager.focusedKey != null ? (_delegate_getKeyBelow = delegate.getKeyBelow) === null || _delegate_getKeyBelow === void 0 ? void 0 : _delegate_getKeyBelow.call(delegate, manager.focusedKey) : (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate);
+          if (nextKey == null && shouldFocusWrap) nextKey = (_delegate_getFirstKey1 = delegate.getFirstKey) === null || _delegate_getFirstKey1 === void 0 ? void 0 : _delegate_getFirstKey1.call(delegate, manager.focusedKey);
+          if (nextKey != null) {
+            e.preventDefault();
+            navigateToKey(nextKey);
+          }
+        }
+        break;
+      case "ArrowUp":
+        if (delegate.getKeyAbove) {
+          var _delegate_getKeyAbove, _delegate_getLastKey, _delegate_getLastKey1;
+          let nextKey = manager.focusedKey != null ? (_delegate_getKeyAbove = delegate.getKeyAbove) === null || _delegate_getKeyAbove === void 0 ? void 0 : _delegate_getKeyAbove.call(delegate, manager.focusedKey) : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate);
+          if (nextKey == null && shouldFocusWrap) nextKey = (_delegate_getLastKey1 = delegate.getLastKey) === null || _delegate_getLastKey1 === void 0 ? void 0 : _delegate_getLastKey1.call(delegate, manager.focusedKey);
+          if (nextKey != null) {
+            e.preventDefault();
+            navigateToKey(nextKey);
+          }
+        }
+        break;
+      case "ArrowLeft":
+        if (delegate.getKeyLeftOf) {
+          var _delegate_getKeyLeftOf, _delegate_getFirstKey2, _delegate_getLastKey2;
+          let nextKey = manager.focusedKey != null ? (_delegate_getKeyLeftOf = delegate.getKeyLeftOf) === null || _delegate_getKeyLeftOf === void 0 ? void 0 : _delegate_getKeyLeftOf.call(delegate, manager.focusedKey) : null;
+          if (nextKey == null && shouldFocusWrap) nextKey = direction === "rtl" ? (_delegate_getFirstKey2 = delegate.getFirstKey) === null || _delegate_getFirstKey2 === void 0 ? void 0 : _delegate_getFirstKey2.call(delegate, manager.focusedKey) : (_delegate_getLastKey2 = delegate.getLastKey) === null || _delegate_getLastKey2 === void 0 ? void 0 : _delegate_getLastKey2.call(delegate, manager.focusedKey);
+          if (nextKey != null) {
+            e.preventDefault();
+            navigateToKey(nextKey, direction === "rtl" ? "first" : "last");
+          }
+        }
+        break;
+      case "ArrowRight":
+        if (delegate.getKeyRightOf) {
+          var _delegate_getKeyRightOf, _delegate_getLastKey3, _delegate_getFirstKey3;
+          let nextKey = manager.focusedKey != null ? (_delegate_getKeyRightOf = delegate.getKeyRightOf) === null || _delegate_getKeyRightOf === void 0 ? void 0 : _delegate_getKeyRightOf.call(delegate, manager.focusedKey) : null;
+          if (nextKey == null && shouldFocusWrap) nextKey = direction === "rtl" ? (_delegate_getLastKey3 = delegate.getLastKey) === null || _delegate_getLastKey3 === void 0 ? void 0 : _delegate_getLastKey3.call(delegate, manager.focusedKey) : (_delegate_getFirstKey3 = delegate.getFirstKey) === null || _delegate_getFirstKey3 === void 0 ? void 0 : _delegate_getFirstKey3.call(delegate, manager.focusedKey);
+          if (nextKey != null) {
+            e.preventDefault();
+            navigateToKey(nextKey, direction === "rtl" ? "last" : "first");
+          }
+        }
+        break;
+      case "Home":
+        if (delegate.getFirstKey) {
+          e.preventDefault();
+          let firstKey = delegate.getFirstKey(manager.focusedKey, $feb5ffebff200149$export$16792effe837dba3(e));
+          manager.setFocusedKey(firstKey);
+          if (firstKey != null) {
+            if ($feb5ffebff200149$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(firstKey);
+            else if (selectOnFocus) manager.replaceSelection(firstKey);
+          }
+        }
+        break;
+      case "End":
+        if (delegate.getLastKey) {
+          e.preventDefault();
+          let lastKey = delegate.getLastKey(manager.focusedKey, $feb5ffebff200149$export$16792effe837dba3(e));
+          manager.setFocusedKey(lastKey);
+          if (lastKey != null) {
+            if ($feb5ffebff200149$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(lastKey);
+            else if (selectOnFocus) manager.replaceSelection(lastKey);
+          }
+        }
+        break;
+      case "PageDown":
+        if (delegate.getKeyPageBelow && manager.focusedKey != null) {
+          let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
+          if (nextKey != null) {
+            e.preventDefault();
+            navigateToKey(nextKey);
+          }
+        }
+        break;
+      case "PageUp":
+        if (delegate.getKeyPageAbove && manager.focusedKey != null) {
+          let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
+          if (nextKey != null) {
+            e.preventDefault();
+            navigateToKey(nextKey);
+          }
+        }
+        break;
+      case "a":
+        if ($feb5ffebff200149$export$16792effe837dba3(e) && manager.selectionMode === "multiple" && disallowSelectAll !== true) {
+          e.preventDefault();
+          manager.selectAll();
+        }
+        break;
+      case "Escape":
+        if (!disallowEmptySelection && manager.selectedKeys.size !== 0) {
+          e.stopPropagation();
+          e.preventDefault();
+          manager.clearSelection();
+        }
+        break;
+      case "Tab":
+        if (!allowsTabNavigation) {
+          if (e.shiftKey) ref.current.focus();
+          else {
+            let walker = FocusScope.$9bf71ea28793e738$export$2d6ec8fc375ceafa(ref.current, {
+              tabbable: true
+            });
+            let next = void 0;
+            let last;
+            do {
+              last = walker.lastChild();
+              if (last) next = last;
+            } while (last);
+            if (next && !next.contains(document.activeElement)) context$1.$7215afc6de606d6b$export$de79e2c695e052f3(next);
+          }
+          break;
+        }
+    }
+  };
+  let scrollPos = React.useRef({
+    top: 0,
+    left: 0
+  });
+  useEvent.$e9faafb641e167db$export$90fc3a17d93f704c(scrollRef, "scroll", isVirtualized ? void 0 : () => {
+    var _scrollRef_current, _scrollRef_current1;
+    var _scrollRef_current_scrollTop, _scrollRef_current_scrollLeft;
+    scrollPos.current = {
+      top: (_scrollRef_current_scrollTop = (_scrollRef_current = scrollRef.current) === null || _scrollRef_current === void 0 ? void 0 : _scrollRef_current.scrollTop) !== null && _scrollRef_current_scrollTop !== void 0 ? _scrollRef_current_scrollTop : 0,
+      left: (_scrollRef_current_scrollLeft = (_scrollRef_current1 = scrollRef.current) === null || _scrollRef_current1 === void 0 ? void 0 : _scrollRef_current1.scrollLeft) !== null && _scrollRef_current_scrollLeft !== void 0 ? _scrollRef_current_scrollLeft : 0
+    };
+  });
+  let onFocus = (e) => {
+    if (manager.isFocused) {
+      if (!e.currentTarget.contains(e.target)) manager.setFocused(false);
+      return;
+    }
+    if (!e.currentTarget.contains(e.target)) return;
+    manager.setFocused(true);
+    if (manager.focusedKey == null) {
+      var _delegate_getLastKey, _delegate_getFirstKey;
+      let navigateToFirstKey = (key) => {
+        if (key != null) {
+          manager.setFocusedKey(key);
+          if (selectOnFocus) manager.replaceSelection(key);
+        }
+      };
+      let relatedTarget = e.relatedTarget;
+      var _manager_lastSelectedKey, _manager_firstSelectedKey;
+      if (relatedTarget && e.currentTarget.compareDocumentPosition(relatedTarget) & Node.DOCUMENT_POSITION_FOLLOWING) navigateToFirstKey((_manager_lastSelectedKey = manager.lastSelectedKey) !== null && _manager_lastSelectedKey !== void 0 ? _manager_lastSelectedKey : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate));
+      else navigateToFirstKey((_manager_firstSelectedKey = manager.firstSelectedKey) !== null && _manager_firstSelectedKey !== void 0 ? _manager_firstSelectedKey : (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate));
+    } else if (!isVirtualized && scrollRef.current) {
+      scrollRef.current.scrollTop = scrollPos.current.top;
+      scrollRef.current.scrollLeft = scrollPos.current.left;
+    }
+    if (manager.focusedKey != null && scrollRef.current) {
+      let element = scrollRef.current.querySelector(`[data-key="${CSS.escape(manager.focusedKey.toString())}"]`);
+      if (element) {
+        if (!element.contains(document.activeElement)) context$1.$7215afc6de606d6b$export$de79e2c695e052f3(element);
+        let modality = useFocusVisible.$507fabe10e71c6fb$export$630ff653c5ada6a9();
+        if (modality === "keyboard") scrollIntoView.$2f04cbc44ee30ce0$export$c826860796309d1b(element, {
+          containingElement: ref.current
+        });
+      }
+    }
+  };
+  let onBlur = (e) => {
+    if (!e.currentTarget.contains(e.relatedTarget)) manager.setFocused(false);
+  };
+  const autoFocusRef = React.useRef(autoFocus);
+  React.useEffect(() => {
+    if (autoFocusRef.current) {
+      var _delegate_getFirstKey, _delegate_getLastKey;
+      let focusedKey = null;
+      var _delegate_getFirstKey1;
+      if (autoFocus === "first") focusedKey = (_delegate_getFirstKey1 = (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate)) !== null && _delegate_getFirstKey1 !== void 0 ? _delegate_getFirstKey1 : null;
+      var _delegate_getLastKey1;
+      if (autoFocus === "last") focusedKey = (_delegate_getLastKey1 = (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate)) !== null && _delegate_getLastKey1 !== void 0 ? _delegate_getLastKey1 : null;
+      let selectedKeys = manager.selectedKeys;
+      if (selectedKeys.size) {
+        for (let key of selectedKeys) if (manager.canSelectItem(key)) {
+          focusedKey = key;
+          break;
+        }
+      }
+      manager.setFocused(true);
+      manager.setFocusedKey(focusedKey);
+      if (focusedKey == null && !shouldUseVirtualFocus && ref.current) focusSafely.$6a99195332edec8b$export$80f3e147d781571c(ref.current);
+    }
+  }, []);
+  let lastFocusedKey = React.useRef(manager.focusedKey);
+  React.useEffect(() => {
+    if (manager.isFocused && manager.focusedKey != null && (manager.focusedKey !== lastFocusedKey.current || autoFocusRef.current) && scrollRef.current && ref.current) {
+      let modality = useFocusVisible.$507fabe10e71c6fb$export$630ff653c5ada6a9();
+      let element = ref.current.querySelector(`[data-key="${CSS.escape(manager.focusedKey.toString())}"]`);
+      if (!element)
+        return;
+      if (modality === "keyboard" || autoFocusRef.current) {
+        scrollIntoView.$2f04cbc44ee30ce0$export$53a0910f038337bd(scrollRef.current, element);
+        if (modality !== "virtual") scrollIntoView.$2f04cbc44ee30ce0$export$c826860796309d1b(element, {
+          containingElement: ref.current
+        });
+      }
+    }
+    if (!shouldUseVirtualFocus && manager.isFocused && manager.focusedKey == null && lastFocusedKey.current != null && ref.current) focusSafely.$6a99195332edec8b$export$80f3e147d781571c(ref.current);
+    lastFocusedKey.current = manager.focusedKey;
+    autoFocusRef.current = false;
+  });
+  useEvent.$e9faafb641e167db$export$90fc3a17d93f704c(ref, "react-aria-focus-scope-restore", (e) => {
+    e.preventDefault();
+    manager.setFocused(true);
+  });
+  let handlers = {
+    onKeyDown,
+    onFocus,
+    onBlur,
+    onMouseDown(e) {
+      if (scrollRef.current === e.target)
+        e.preventDefault();
+    }
+  };
+  let { typeSelectProps } = $fb3050f43d946246$export$e32c88dfddc6e1d8({
+    keyboardDelegate: delegate,
+    selectionManager: manager
+  });
+  if (!disallowTypeAhead) handlers = mergeProps.$3ef42575df84b30b$export$9d1611c77c2fe928(typeSelectProps, handlers);
+  let tabIndex = void 0;
+  if (!shouldUseVirtualFocus) tabIndex = manager.focusedKey == null ? 0 : -1;
+  return {
+    collectionProps: __spreadProps(__spreadValues({}, handlers), {
+      tabIndex
+    })
+  };
+}
+function $880e95eb8b93ba9a$export$ecf600387e221c37(options) {
+  let { selectionManager: manager, key, ref, shouldSelectOnPressUp, shouldUseVirtualFocus, focus, isDisabled, onAction, allowsDifferentPressOrigin, linkBehavior = "action" } = options;
+  let router = usePress.$ea8dcbcb9ea1b556$export$9a302a45f65d0572();
+  let onSelect = (e) => {
+    if (e.pointerType === "keyboard" && $feb5ffebff200149$export$d3e3bd3e26688c04(e)) manager.toggleSelection(key);
+    else {
+      if (manager.selectionMode === "none") return;
+      if (manager.isLink(key)) {
+        if (linkBehavior === "selection" && ref.current) {
+          let itemProps2 = manager.getItemProps(key);
+          router.open(ref.current, e, itemProps2.href, itemProps2.routerOptions);
+          manager.setSelectedKeys(manager.selectedKeys);
+          return;
+        } else if (linkBehavior === "override" || linkBehavior === "none") return;
+      }
+      if (manager.selectionMode === "single") {
+        if (manager.isSelected(key) && !manager.disallowEmptySelection) manager.toggleSelection(key);
+        else manager.replaceSelection(key);
+      } else if (e && e.shiftKey) manager.extendSelection(key);
+      else if (manager.selectionBehavior === "toggle" || e && ($feb5ffebff200149$export$16792effe837dba3(e) || e.pointerType === "touch" || e.pointerType === "virtual"))
+        manager.toggleSelection(key);
+      else manager.replaceSelection(key);
+    }
+  };
+  React.useEffect(() => {
+    let isFocused = key === manager.focusedKey;
+    if (isFocused && manager.isFocused && !shouldUseVirtualFocus) {
+      if (focus) focus();
+      else if (document.activeElement !== ref.current && ref.current) focusSafely.$6a99195332edec8b$export$80f3e147d781571c(ref.current);
+    }
+  }, [
+    ref,
+    key,
+    manager.focusedKey,
+    manager.childFocusStrategy,
+    manager.isFocused,
+    shouldUseVirtualFocus
+  ]);
+  isDisabled = isDisabled || manager.isDisabled(key);
+  let itemProps = {};
+  if (!shouldUseVirtualFocus && !isDisabled) itemProps = {
+    tabIndex: key === manager.focusedKey ? 0 : -1,
+    onFocus(e) {
+      if (e.target === ref.current) manager.setFocusedKey(key);
+    }
+  };
+  else if (isDisabled) itemProps.onMouseDown = (e) => {
+    e.preventDefault();
+  };
+  let isLinkOverride = manager.isLink(key) && linkBehavior === "override";
+  let hasLinkAction = manager.isLink(key) && linkBehavior !== "selection" && linkBehavior !== "none";
+  let allowsSelection = !isDisabled && manager.canSelectItem(key) && !isLinkOverride;
+  let allowsActions = (onAction || hasLinkAction) && !isDisabled;
+  let hasPrimaryAction = allowsActions && (manager.selectionBehavior === "replace" ? !allowsSelection : !allowsSelection || manager.isEmpty);
+  let hasSecondaryAction = allowsActions && allowsSelection && manager.selectionBehavior === "replace";
+  let hasAction = hasPrimaryAction || hasSecondaryAction;
+  let modality = React.useRef(null);
+  let longPressEnabled = hasAction && allowsSelection;
+  let longPressEnabledOnPressStart = React.useRef(false);
+  let hadPrimaryActionOnPressStart = React.useRef(false);
+  let performAction = (e) => {
+    if (onAction) onAction();
+    if (hasLinkAction && ref.current) {
+      let itemProps2 = manager.getItemProps(key);
+      router.open(ref.current, e, itemProps2.href, itemProps2.routerOptions);
+    }
+  };
+  let itemPressProps = {};
+  if (shouldSelectOnPressUp) {
+    itemPressProps.onPressStart = (e) => {
+      modality.current = e.pointerType;
+      longPressEnabledOnPressStart.current = longPressEnabled;
+      if (e.pointerType === "keyboard" && (!hasAction || $880e95eb8b93ba9a$var$isSelectionKey())) onSelect(e);
+    };
+    if (!allowsDifferentPressOrigin) itemPressProps.onPress = (e) => {
+      if (hasPrimaryAction || hasSecondaryAction && e.pointerType !== "mouse") {
+        if (e.pointerType === "keyboard" && !$880e95eb8b93ba9a$var$isActionKey()) return;
+        performAction(e);
+      } else if (e.pointerType !== "keyboard" && allowsSelection) onSelect(e);
+    };
+    else {
+      itemPressProps.onPressUp = hasPrimaryAction ? void 0 : (e) => {
+        if (e.pointerType !== "keyboard" && allowsSelection) onSelect(e);
+      };
+      itemPressProps.onPress = hasPrimaryAction ? performAction : void 0;
+    }
+  } else {
+    itemPressProps.onPressStart = (e) => {
+      modality.current = e.pointerType;
+      longPressEnabledOnPressStart.current = longPressEnabled;
+      hadPrimaryActionOnPressStart.current = hasPrimaryAction;
+      if (allowsSelection && (e.pointerType === "mouse" && !hasPrimaryAction || e.pointerType === "keyboard" && (!allowsActions || $880e95eb8b93ba9a$var$isSelectionKey()))) onSelect(e);
+    };
+    itemPressProps.onPress = (e) => {
+      if (e.pointerType === "touch" || e.pointerType === "pen" || e.pointerType === "virtual" || e.pointerType === "keyboard" && hasAction && $880e95eb8b93ba9a$var$isActionKey() || e.pointerType === "mouse" && hadPrimaryActionOnPressStart.current) {
+        if (hasAction) performAction(e);
+        else if (allowsSelection) onSelect(e);
+      }
+    };
+  }
+  itemProps["data-key"] = key;
+  itemPressProps.preventFocusOnPress = shouldUseVirtualFocus;
+  let { pressProps, isPressed } = usePress.$f6c31cce2adf654f$export$45712eceda6fad21(itemPressProps);
+  let onDoubleClick = hasSecondaryAction ? (e) => {
+    if (modality.current === "mouse") {
+      e.stopPropagation();
+      e.preventDefault();
+      performAction(e);
+    }
+  } : void 0;
+  let { longPressProps } = $8a26561d2877236e$export$c24ed0104d07eab9({
+    isDisabled: !longPressEnabled,
+    onLongPress(e) {
+      if (e.pointerType === "touch") {
+        onSelect(e);
+        manager.setSelectionBehavior("toggle");
+      }
+    }
+  });
+  let onDragStartCapture = (e) => {
+    if (modality.current === "touch" && longPressEnabledOnPressStart.current) e.preventDefault();
+  };
+  let onClick = manager.isLink(key) ? (e) => {
+    if (!usePress.$ea8dcbcb9ea1b556$export$95185d699e05d4d7.isOpening) e.preventDefault();
+  } : void 0;
+  return {
+    itemProps: mergeProps.$3ef42575df84b30b$export$9d1611c77c2fe928(itemProps, allowsSelection || hasPrimaryAction ? pressProps : {}, longPressEnabled ? longPressProps : {}, {
+      onDoubleClick,
+      onDragStartCapture,
+      onClick
+    }),
+    isPressed,
+    isSelected: manager.isSelected(key),
+    isFocused: manager.isFocused && manager.focusedKey === key,
+    isDisabled,
+    allowsSelection,
+    hasAction
+  };
+}
+function $880e95eb8b93ba9a$var$isActionKey() {
+  let event = window.event;
+  return (event === null || event === void 0 ? void 0 : event.key) === "Enter";
+}
+function $880e95eb8b93ba9a$var$isSelectionKey() {
+  let event = window.event;
+  return (event === null || event === void 0 ? void 0 : event.key) === " " || (event === null || event === void 0 ? void 0 : event.code) === "Space";
+}
+exports.$880e95eb8b93ba9a$export$ecf600387e221c37 = $880e95eb8b93ba9a$export$ecf600387e221c37;
+exports.$8a26561d2877236e$export$c24ed0104d07eab9 = $8a26561d2877236e$export$c24ed0104d07eab9;
+exports.$ae20dd8cbca75726$export$d6daf82dcd84e87c = $ae20dd8cbca75726$export$d6daf82dcd84e87c;
+exports.$fb3050f43d946246$export$e32c88dfddc6e1d8 = $fb3050f43d946246$export$e32c88dfddc6e1d8;