@tamagui/floating 2.0.0-rc.3 → 2.0.0-rc.31

package/dist/cjs/interactions/useInteractions.native.js

@@ -0,0 +1,164 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var useInteractions_exports = {};
+__export(useInteractions_exports, {
+  useInteractions: () => useInteractions
+});
+module.exports = __toCommonJS(useInteractions_exports);
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function useInteractions(propsList) {
+  var filtered = propsList.filter(Boolean),
+    referenceFns = /* @__PURE__ */new Map(),
+    floatingFns = /* @__PURE__ */new Map(),
+    itemFns = /* @__PURE__ */new Map(),
+    referenceStatic = {},
+    floatingStatic = {},
+    _iteratorNormalCompletion = !0,
+    _didIteratorError = !1,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = filtered[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+      var props = _step.value;
+      props.reference && collectProps(props.reference, referenceFns, referenceStatic), props.floating && collectProps(props.floating, floatingFns, floatingStatic), props.item && _type_of(props.item) === "object" && collectProps(props.item, itemFns, {});
+    }
+  } catch (err) {
+    _didIteratorError = !0, _iteratorError = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+  return {
+    getReferenceProps(userProps) {
+      return buildProps(referenceFns, referenceStatic, userProps);
+    },
+    getFloatingProps(userProps) {
+      return buildProps(floatingFns, floatingStatic, userProps);
+    },
+    getItemProps(userProps) {
+      return buildProps(itemFns, {}, userProps);
+    }
+  };
+}
+function collectProps(props, fnMap, staticMap) {
+  var _iteratorNormalCompletion = !0,
+    _didIteratorError = !1,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = Object.keys(props)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+      var key = _step.value;
+      if (typeof props[key] == "function") {
+        var arr = fnMap.get(key);
+        arr || (arr = [], fnMap.set(key, arr)), arr.push(props[key]);
+      } else staticMap[key] = props[key];
+    }
+  } catch (err) {
+    _didIteratorError = !0, _iteratorError = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+}
+function buildProps(fnMap, staticProps, userProps) {
+  var result = {
+      ...staticProps
+    },
+    _iteratorNormalCompletion = !0,
+    _didIteratorError = !1,
+    _iteratorError = void 0;
+  try {
+    for (var _loop = function () {
+        var [key, fns] = _step.value,
+          hookHandler = function () {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+            var _iteratorNormalCompletion2 = !0,
+              _didIteratorError2 = !1,
+              _iteratorError2 = void 0;
+            try {
+              for (var _iterator2 = fns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
+                var fn = _step2.value,
+                  result2 = fn(...args);
+                if (result2 !== void 0) return result2;
+              }
+            } catch (err) {
+              _didIteratorError2 = !0, _iteratorError2 = err;
+            } finally {
+              try {
+                !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
+              } finally {
+                if (_didIteratorError2) throw _iteratorError2;
+              }
+            }
+          };
+        result[key] = hookHandler;
+      }, _iterator = fnMap[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) _loop();
+  } catch (err) {
+    _didIteratorError = !0, _iteratorError = err;
+  } finally {
+    try {
+      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+  if (userProps) {
+    var _iteratorNormalCompletion1 = !0,
+      _didIteratorError1 = !1,
+      _iteratorError1 = void 0;
+    try {
+      for (var _loop1 = function () {
+          var key = _step1.value;
+          if (key === "style") result.style = {
+            ...result.style,
+            ...userProps.style
+          };else if (typeof userProps[key] == "function" && result[key]) {
+            var hookFn = result[key],
+              userFn = userProps[key];
+            result[key] = function () {
+              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+              userFn(...args), hookFn(...args);
+            };
+          } else result[key] = userProps[key];
+        }, _iterator1 = Object.keys(userProps)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) _loop1();
+    } catch (err) {
+      _didIteratorError1 = !0, _iteratorError1 = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+      } finally {
+        if (_didIteratorError1) throw _iteratorError1;
+      }
+    }
+  }
+  return result;
+}
+//# sourceMappingURL=useInteractions.native.js.map

package/dist/cjs/interactions/useInteractions.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useInteractions_exports","__export","useInteractions","module","exports","_type_of","obj","Symbol","constructor","propsList","filtered","filter","Boolean","referenceFns","Map","floatingFns","itemFns","referenceStatic","floatingStatic","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","iterator","_step","next","done","props","reference","collectProps","floating","item","err","return","getReferenceProps","userProps","buildProps","getFloatingProps","getItemProps","fnMap","staticMap","Object","keys","key","arr","get","set","push"],"sources":["../../../src/interactions/useInteractions.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/interactions/useListNavigation.cjs

@@ -0,0 +1,253 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var useListNavigation_exports = {};
+__export(useListNavigation_exports, {
+  useListNavigation: () => useListNavigation
+});
+module.exports = __toCommonJS(useListNavigation_exports);
+var import_react = require("react"),
+  import_use_event = require("@tamagui/use-event"),
+  import_utils = require("./utils.cjs");
+const ARROW_UP = "ArrowUp",
+  ARROW_DOWN = "ArrowDown",
+  ARROW_LEFT = "ArrowLeft",
+  ARROW_RIGHT = "ArrowRight";
+function doSwitch(orientation, vertical, horizontal) {
+  switch (orientation) {
+    case "vertical":
+      return vertical;
+    case "horizontal":
+      return horizontal;
+    default:
+      return vertical || horizontal;
+  }
+}
+function isMainOrientationKey(key, orientation) {
+  return doSwitch(orientation, key === ARROW_UP || key === ARROW_DOWN, key === ARROW_LEFT || key === ARROW_RIGHT);
+}
+function isMainOrientationToEndKey(key, orientation, rtl) {
+  return doSwitch(orientation, key === ARROW_DOWN, rtl ? key === ARROW_LEFT : key === ARROW_RIGHT) || key === "Enter" || key === " " || key === "";
+}
+function isCrossOrientationOpenKey(key, orientation, rtl) {
+  return doSwitch(orientation, rtl ? key === ARROW_LEFT : key === ARROW_RIGHT, key === ARROW_DOWN);
+}
+function isCrossOrientationCloseKey(key, orientation, rtl) {
+  return doSwitch(orientation, rtl ? key === ARROW_RIGHT : key === ARROW_LEFT, key === ARROW_UP);
+}
+function useListNavigation(context, props) {
+  const {
+      open,
+      onOpenChange,
+      elements
+    } = context,
+    {
+      listRef,
+      activeIndex,
+      onNavigate: unstable_onNavigate = () => {},
+      enabled = !0,
+      selectedIndex = null,
+      allowEscape = !1,
+      loop = !1,
+      nested = !1,
+      rtl = !1,
+      virtual = !1,
+      focusItemOnOpen = "auto",
+      focusItemOnHover = !0,
+      openOnArrowKeyDown = !0,
+      disabledIndices = void 0,
+      orientation = "vertical",
+      scrollItemIntoView = !0
+    } = props,
+    typeableComboboxReference = (0, import_utils.isTypeableCombobox)(elements.domReference),
+    focusItemOnOpenRef = (0, import_react.useRef)(focusItemOnOpen),
+    indexRef = (0, import_react.useRef)(selectedIndex ?? -1),
+    keyRef = (0, import_react.useRef)(null),
+    isPointerModalityRef = (0, import_react.useRef)(!0),
+    previousMountedRef = (0, import_react.useRef)(!!elements.floating),
+    previousOpenRef = (0, import_react.useRef)(open),
+    forceSyncFocusRef = (0, import_react.useRef)(!1),
+    forceScrollIntoViewRef = (0, import_react.useRef)(!1),
+    disabledIndicesRef = (0, import_react.useRef)(disabledIndices);
+  disabledIndicesRef.current = disabledIndices;
+  const latestOpenRef = (0, import_react.useRef)(open);
+  latestOpenRef.current = open;
+  const scrollItemIntoViewRef = (0, import_react.useRef)(scrollItemIntoView);
+  scrollItemIntoViewRef.current = scrollItemIntoView;
+  const selectedIndexRef = (0, import_react.useRef)(selectedIndex);
+  selectedIndexRef.current = selectedIndex;
+  const stableOnNavigate = (0, import_use_event.useEvent)(unstable_onNavigate),
+    [activeId, setActiveId] = (0, import_react.useState)(),
+    onNavigate = (0, import_use_event.useEvent)(() => {
+      stableOnNavigate(indexRef.current === -1 ? null : indexRef.current);
+    }),
+    previousOnNavigateRef = (0, import_react.useRef)(onNavigate),
+    focusItem = (0, import_use_event.useEvent)(() => {
+      function runFocus(item2) {
+        virtual ? setActiveId(item2.id) : (0, import_utils.enqueueFocus)(item2, {
+          sync: forceSyncFocusRef.current,
+          preventScroll: !0
+        });
+      }
+      const initialItem = listRef.current[indexRef.current],
+        forceScrollIntoView = forceScrollIntoViewRef.current;
+      initialItem && runFocus(initialItem), (forceSyncFocusRef.current ? v => v() : requestAnimationFrame)(() => {
+        const waitedItem = listRef.current[indexRef.current] || initialItem;
+        if (!waitedItem) return;
+        initialItem || runFocus(waitedItem);
+        const scrollIntoViewOptions = scrollItemIntoViewRef.current;
+        scrollIntoViewOptions && waitedItem && (forceScrollIntoView || !isPointerModalityRef.current) && waitedItem.scrollIntoView?.(typeof scrollIntoViewOptions == "boolean" ? {
+          block: "nearest",
+          inline: "nearest"
+        } : scrollIntoViewOptions);
+      });
+    });
+  (0, import_react.useLayoutEffect)(() => {
+    enabled && (open && elements.floating ? focusItemOnOpenRef.current && selectedIndex != null && (forceScrollIntoViewRef.current = !0, indexRef.current = selectedIndex, onNavigate()) : previousMountedRef.current && (indexRef.current = -1, previousOnNavigateRef.current()));
+  }, [enabled, open, elements.floating, selectedIndex, onNavigate]), (0, import_react.useLayoutEffect)(() => {
+    if (enabled && open && elements.floating) if (activeIndex == null) {
+      if (forceSyncFocusRef.current = !1, selectedIndexRef.current != null) return;
+      if (previousMountedRef.current && (indexRef.current = -1, focusItem()), (!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === !0 && keyRef.current == null)) {
+        let runs = 0;
+        const waitForListPopulated = () => {
+          listRef.current[0] == null ? (runs < 2 && (runs ? requestAnimationFrame : queueMicrotask)(waitForListPopulated), runs++) : (indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? (0, import_utils.getMinListIndex)(listRef, disabledIndicesRef.current) : (0, import_utils.getMaxListIndex)(listRef, disabledIndicesRef.current), keyRef.current = null, onNavigate());
+        };
+        waitForListPopulated();
+      }
+    } else (0, import_utils.isIndexOutOfListBounds)(listRef, activeIndex) || (indexRef.current = activeIndex, focusItem(), forceScrollIntoViewRef.current = !1);
+  }, [enabled, open, elements.floating, activeIndex, selectedIndexRef, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]), (0, import_react.useLayoutEffect)(() => {
+    previousOnNavigateRef.current = onNavigate, previousOpenRef.current = open, previousMountedRef.current = !!elements.floating;
+  }), (0, import_react.useLayoutEffect)(() => {
+    open || (keyRef.current = null, focusItemOnOpenRef.current = focusItemOnOpen);
+  }, [open, focusItemOnOpen]);
+  const hasActiveIndex = activeIndex != null,
+    commonOnKeyDown = (0, import_use_event.useEvent)(event => {
+      if (isPointerModalityRef.current = !1, forceSyncFocusRef.current = !0, event.which === 229 || !latestOpenRef.current && event.currentTarget === elements.floating) return;
+      if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {
+        (0, import_utils.stopEvent)(event), onOpenChange(!1, event.nativeEvent, "list-navigation"), (0, import_utils.isHTMLElement)(elements.domReference) && elements.domReference.focus();
+        return;
+      }
+      const currentIndex = indexRef.current,
+        minIndex = (0, import_utils.getMinListIndex)(listRef, disabledIndices),
+        maxIndex = (0, import_utils.getMaxListIndex)(listRef, disabledIndices);
+      if (typeableComboboxReference || (event.key === "Home" && ((0, import_utils.stopEvent)(event), indexRef.current = minIndex, onNavigate()), event.key === "End" && ((0, import_utils.stopEvent)(event), indexRef.current = maxIndex, onNavigate())), isMainOrientationKey(event.key, orientation)) {
+        if ((0, import_utils.stopEvent)(event), open && !virtual && (0, import_utils.activeElement)(event.currentTarget.ownerDocument) === event.currentTarget) {
+          indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex, onNavigate();
+          return;
+        }
+        isMainOrientationToEndKey(event.key, orientation, rtl) ? loop ? indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : (0, import_utils.findNonDisabledListIndex)(listRef, {
+          startingIndex: currentIndex,
+          disabledIndices
+        }) : indexRef.current = Math.min(maxIndex, (0, import_utils.findNonDisabledListIndex)(listRef, {
+          startingIndex: currentIndex,
+          disabledIndices
+        })) : loop ? indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : (0, import_utils.findNonDisabledListIndex)(listRef, {
+          startingIndex: currentIndex,
+          decrement: !0,
+          disabledIndices
+        }) : indexRef.current = Math.max(minIndex, (0, import_utils.findNonDisabledListIndex)(listRef, {
+          startingIndex: currentIndex,
+          decrement: !0,
+          disabledIndices
+        })), (0, import_utils.isIndexOutOfListBounds)(listRef, indexRef.current) && (indexRef.current = -1), onNavigate();
+      }
+    }),
+    ariaActiveDescendantProp = (0, import_react.useMemo)(() => virtual && open && hasActiveIndex && {
+      "aria-activedescendant": activeId
+    }, [virtual, open, hasActiveIndex, activeId]),
+    floating = (0, import_react.useMemo)(() => ({
+      "aria-orientation": orientation === "both" ? void 0 : orientation,
+      ...(typeableComboboxReference ? {} : ariaActiveDescendantProp),
+      onKeyDown: commonOnKeyDown,
+      onPointerMove() {
+        isPointerModalityRef.current = !0;
+      }
+    }), [ariaActiveDescendantProp, commonOnKeyDown, orientation, typeableComboboxReference]),
+    reference = (0, import_react.useMemo)(() => {
+      function checkVirtualMouse(event) {
+        focusItemOnOpen === "auto" && (0, import_utils.isVirtualClick)(event.nativeEvent) && (focusItemOnOpenRef.current = !0);
+      }
+      function checkVirtualPointer(event) {
+        focusItemOnOpenRef.current = focusItemOnOpen, focusItemOnOpen === "auto" && (0, import_utils.isVirtualPointerEvent)(event.nativeEvent) && (focusItemOnOpenRef.current = !0);
+      }
+      return {
+        ...ariaActiveDescendantProp,
+        onKeyDown(event) {
+          isPointerModalityRef.current = !1;
+          const isArrowKey = event.key.startsWith("Arrow"),
+            isCrossOpenKey = isCrossOrientationOpenKey(event.key, orientation, rtl),
+            isMainKey = isMainOrientationKey(event.key, orientation),
+            isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === "Enter" || event.key.trim() === "";
+          if (virtual && open) return commonOnKeyDown(event);
+          if (!(!open && !openOnArrowKeyDown && isArrowKey)) {
+            if (isNavigationKey && (keyRef.current = event.key), nested) {
+              isCrossOpenKey && ((0, import_utils.stopEvent)(event), open ? (indexRef.current = (0, import_utils.getMinListIndex)(listRef, disabledIndicesRef.current), onNavigate()) : onOpenChange(!0, event.nativeEvent, "list-navigation"));
+              return;
+            }
+            isMainKey && (selectedIndex != null && (indexRef.current = selectedIndex), (0, import_utils.stopEvent)(event), !open && openOnArrowKeyDown ? onOpenChange(!0, event.nativeEvent, "list-navigation") : commonOnKeyDown(event), open && onNavigate());
+          }
+        },
+        onFocus() {
+          open && !virtual && (indexRef.current = -1, onNavigate());
+        },
+        onPointerDown: checkVirtualPointer,
+        onPointerEnter: checkVirtualPointer,
+        onMouseDown: checkVirtualMouse,
+        onClick: checkVirtualMouse
+      };
+    }, [ariaActiveDescendantProp, commonOnKeyDown, disabledIndicesRef, focusItemOnOpen, listRef, nested, onNavigate, onOpenChange, open, openOnArrowKeyDown, orientation, rtl, selectedIndex, virtual]),
+    item = (0, import_react.useMemo)(() => {
+      function syncCurrentTarget(currentTarget) {
+        if (!latestOpenRef.current) return;
+        const index = listRef.current.indexOf(currentTarget);
+        index !== -1 && indexRef.current !== index && (indexRef.current = index, onNavigate());
+      }
+      return {
+        onFocus({
+          currentTarget
+        }) {
+          forceSyncFocusRef.current = !0, syncCurrentTarget(currentTarget);
+        },
+        onClick: ({
+          currentTarget
+        }) => currentTarget.focus({
+          preventScroll: !0
+        }),
+        // safari
+        onMouseMove({
+          currentTarget
+        }) {
+          forceSyncFocusRef.current = !0, forceScrollIntoViewRef.current = !1, focusItemOnHover && syncCurrentTarget(currentTarget);
+        },
+        onPointerLeave({
+          pointerType
+        }) {
+          !isPointerModalityRef.current || pointerType === "touch" || (forceSyncFocusRef.current = !0, focusItemOnHover && (indexRef.current = -1, onNavigate(), virtual || elements.floating?.focus({
+            preventScroll: !0
+          })));
+        }
+      };
+    }, [latestOpenRef, focusItemOnHover, listRef, onNavigate, virtual, elements.floating]);
+  return (0, import_react.useMemo)(() => enabled ? {
+    reference,
+    floating,
+    item
+  } : {}, [enabled, reference, floating, item]);
+}