@tamagui/floating 2.0.0-rc.4 → 2.0.0-rc.40

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

@@ -0,0 +1,139 @@
+"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: 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;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useFocus_exports = {};
+__export(useFocus_exports, {
+  useFocus: () => useFocus
+});
+module.exports = __toCommonJS(useFocus_exports);
+var import_react = require("react");
+var import_utils = require("./utils.native.js");
+function isMacSafari() {
+  return (0, import_utils.isMac)() && (0, import_utils.isSafari)();
+}
+function useFocus(context) {
+  var props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var {
+    open,
+    onOpenChange,
+    events,
+    dataRef,
+    elements
+  } = context;
+  var {
+    enabled = true,
+    visibleOnly = true
+  } = props;
+  var blockFocusRef = (0, import_react.useRef)(false);
+  var timeoutRef = (0, import_react.useRef)(-1);
+  var keyboardModalityRef = (0, import_react.useRef)(true);
+  (0, import_react.useEffect)(function () {
+    if (!enabled) return;
+    var win = (0, import_utils.getDocument)(elements.domReference).defaultView || window;
+    function onBlur() {
+      if (!open && (0, import_utils.isHTMLElement)(elements.domReference) && elements.domReference === (0, import_utils.activeElement)((0, import_utils.getDocument)(elements.domReference))) {
+        blockFocusRef.current = true;
+      }
+    }
+    function onKeyDown() {
+      keyboardModalityRef.current = true;
+    }
+    function onPointerDown() {
+      keyboardModalityRef.current = false;
+    }
+    win.addEventListener("blur", onBlur);
+    if (isMacSafari()) {
+      win.addEventListener("keydown", onKeyDown, true);
+      win.addEventListener("pointerdown", onPointerDown, true);
+    }
+    return function () {
+      win.removeEventListener("blur", onBlur);
+      if (isMacSafari()) {
+        win.removeEventListener("keydown", onKeyDown, true);
+        win.removeEventListener("pointerdown", onPointerDown, true);
+      }
+    };
+  }, [elements.domReference, open, enabled]);
+  (0, import_react.useEffect)(function () {
+    if (!enabled) return;
+    if (!events) return;
+    function handleOpenChange(param) {
+      var {
+        reason
+      } = param;
+      if (reason === "reference-press" || reason === "escape-key") {
+        blockFocusRef.current = true;
+      }
+    }
+    events.on("openchange", handleOpenChange);
+    return function () {
+      events.off("openchange", handleOpenChange);
+    };
+  }, [events, enabled]);
+  (0, import_react.useEffect)(function () {
+    return function () {
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+    };
+  }, []);
+  var reference = (0, import_react.useMemo)(function () {
+    return {
+      onMouseLeave() {
+        blockFocusRef.current = false;
+      },
+      onFocus(event) {
+        if (blockFocusRef.current) return;
+        var target = (0, import_utils.getTarget)(event.nativeEvent);
+        if (visibleOnly && (0, import_utils.isElement)(target)) {
+          if (isMacSafari() && !event.relatedTarget) {
+            if (!keyboardModalityRef.current && !(0, import_utils.isTypeableElement)(target)) {
+              return;
+            }
+          } else if (!(0, import_utils.matchesFocusVisible)(target)) {
+            return;
+          }
+        }
+        onOpenChange(true, event.nativeEvent, "focus");
+      },
+      onBlur(event) {
+        blockFocusRef.current = false;
+        var relatedTarget = event.relatedTarget;
+        var nativeEvent = event.nativeEvent;
+        timeoutRef.current = window.setTimeout(function () {
+          var activeEl = (0, import_utils.activeElement)(elements.domReference ? elements.domReference.ownerDocument : document);
+          if (!relatedTarget && activeEl === elements.domReference) return;
+          if ((0, import_utils.contains)(context.refs.floating.current, activeEl) || (0, import_utils.contains)(elements.domReference, activeEl)) {
+            return;
+          }
+          onOpenChange(false, nativeEvent, "focus");
+        });
+      }
+    };
+  }, [context.refs.floating, elements.domReference, onOpenChange, visibleOnly]);
+  return (0, import_react.useMemo)(function () {
+    return enabled ? {
+      reference
+    } : {};
+  }, [enabled, reference]);
+}
+//# sourceMappingURL=useFocus.native.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useFocus_exports","__export","useFocus","module","exports","import_react","require","import_utils","isMacSafari","isMac","isSafari","context","props","arguments","length","open","onOpenChange","events","dataRef","elements","enabled","visibleOnly","blockFocusRef","useRef","timeoutRef","keyboardModalityRef","useEffect","win","getDocument","domReference","defaultView","window","onBlur","isHTMLElement","activeElement","current","onKeyDown","onPointerDown","addEventListener","removeEventListener","handleOpenChange","param","reason","on","off","clearTimeoutIfSet","reference","useMemo","onMouseLeave","onFocus","event","target","getTarget","nativeEvent","isElement","relatedTarget","isTypeableElement","matchesFocusVisible","setTimeout","activeEl","ownerDocument","document","contains","refs","floating"],"sources":["../../../src/interactions/useFocus.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/interactions/useHover.cjs

@@ -0,0 +1,357 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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: 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;
+};
+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: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useHover_exports = {};
+__export(useHover_exports, {
+  getDelay: () => getDelay,
+  useHover: () => useHover
+});
+module.exports = __toCommonJS(useHover_exports);
+var React = __toESM(require("react"), 1);
+var import_use_event = require("@tamagui/use-event");
+var import_utils = require("./utils.cjs");
+const safePolygonIdentifier = "data-floating-ui-safe-polygon";
+function getDelay(value, prop, pointerType) {
+  if (pointerType && !(0, import_utils.isMouseLikePointerType)(pointerType)) {
+    return 0;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return value?.[prop];
+}
+function useHover(context, props = {}) {
+  const {
+    open,
+    onOpenChange,
+    dataRef,
+    events,
+    elements
+  } = context;
+  const {
+    enabled = true,
+    delay = 0,
+    handleClose = null,
+    mouseOnly = false,
+    restMs = 0,
+    move = true
+  } = props;
+  const handleCloseRef = React.useRef(handleClose);
+  handleCloseRef.current = handleClose;
+  const delayRef = React.useRef(delay);
+  delayRef.current = delay;
+  const openRef = React.useRef(open);
+  openRef.current = open;
+  const restMsRef = React.useRef(restMs);
+  restMsRef.current = restMs;
+  const stableOnOpenChange = (0, import_use_event.useEvent)(onOpenChange);
+  const pointerTypeRef = React.useRef(void 0);
+  const timeoutRef = React.useRef(-1);
+  const handlerRef = React.useRef(void 0);
+  const restTimeoutRef = React.useRef(-1);
+  const blockMouseMoveRef = React.useRef(true);
+  const performedPointerEventsMutationRef = React.useRef(false);
+  const unbindMouseMoveRef = React.useRef(() => {});
+  const restTimeoutPendingRef = React.useRef(false);
+  const isHoverOpen = (0, import_use_event.useEvent)(() => {
+    const type = dataRef.current.openEvent?.type;
+    return type?.includes("mouse") && type !== "mousedown";
+  });
+  React.useEffect(() => {
+    if (!enabled) return;
+    if (!events) return;
+    function onOpenChange2({
+      open: open2
+    }) {
+      if (!open2) {
+        (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+        (0, import_utils.clearTimeoutIfSet)(restTimeoutRef);
+        blockMouseMoveRef.current = true;
+        restTimeoutPendingRef.current = false;
+      }
+    }
+    events.on("openchange", onOpenChange2);
+    return () => {
+      events.off("openchange", onOpenChange2);
+    };
+  }, [enabled, events]);
+  const closeWithDelay = (0, import_use_event.useEvent)((event, runElseBranch = true, reason = "hover") => {
+    const closeDelay = getDelay(delayRef.current, "close", pointerTypeRef.current);
+    if (closeDelay && !handlerRef.current) {
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+      timeoutRef.current = window.setTimeout(() => stableOnOpenChange(false, event, reason), closeDelay);
+    } else if (runElseBranch) {
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+      stableOnOpenChange(false, event, reason);
+    }
+  });
+  const cleanupMouseMoveHandler = (0, import_use_event.useEvent)(() => {
+    unbindMouseMoveRef.current();
+    handlerRef.current = void 0;
+    if (context.handleCloseActiveRef) {
+      context.handleCloseActiveRef.current = false;
+    }
+  });
+  const clearPointerEvents = (0, import_use_event.useEvent)(() => {
+    if (performedPointerEventsMutationRef.current) {
+      const body = (0, import_utils.getDocument)(elements.floating).body;
+      body.style.pointerEvents = "";
+      body.removeAttribute(safePolygonIdentifier);
+      performedPointerEventsMutationRef.current = false;
+    }
+  });
+  const isClickLikeOpenEvent = (0, import_use_event.useEvent)(() => {
+    return dataRef.current.openEvent ? ["click", "mousedown"].includes(dataRef.current.openEvent.type) : false;
+  });
+  React.useEffect(() => {
+    if (!enabled) return;
+    function onReferenceMouseEnter(event) {
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+      blockMouseMoveRef.current = false;
+      if (mouseOnly && !(0, import_utils.isMouseLikePointerType)(pointerTypeRef.current) || restMsRef.current > 0 && !getDelay(delayRef.current, "open")) {
+        return;
+      }
+      const openDelay = getDelay(delayRef.current, "open", pointerTypeRef.current);
+      if (openDelay) {
+        timeoutRef.current = window.setTimeout(() => {
+          if (!openRef.current) {
+            stableOnOpenChange(true, event, "hover");
+          }
+        }, openDelay);
+      } else if (!open) {
+        stableOnOpenChange(true, event, "hover");
+      }
+    }
+    function onReferenceMouseLeave(event) {
+      if (isClickLikeOpenEvent()) {
+        clearPointerEvents();
+        return;
+      }
+      if (context.triggerElements?.hasElement(event.relatedTarget)) {
+        return;
+      }
+      unbindMouseMoveRef.current();
+      const doc = (0, import_utils.getDocument)(elements.floating);
+      (0, import_utils.clearTimeoutIfSet)(restTimeoutRef);
+      restTimeoutPendingRef.current = false;
+      if (handleCloseRef.current) {
+        if (!open) {
+          (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+        }
+        const placement = dataRef.current.placement || "bottom";
+        const reference2 = elements.domReference;
+        const floating = elements.floating;
+        if (!reference2 || !floating) return;
+        handlerRef.current = handleCloseRef.current({
+          x: event.clientX,
+          y: event.clientY,
+          placement,
+          elements: {
+            reference: reference2,
+            floating,
+            domReference: reference2
+          },
+          onClose() {
+            if (context.handleCloseActiveRef) {
+              context.handleCloseActiveRef.current = false;
+            }
+            clearPointerEvents();
+            cleanupMouseMoveHandler();
+            if (!isClickLikeOpenEvent()) {
+              closeWithDelay(event, true, "safe-polygon");
+            }
+          }
+        });
+        if (context.handleCloseActiveRef) {
+          context.handleCloseActiveRef.current = true;
+        }
+        const handler = handlerRef.current;
+        doc.addEventListener("mousemove", handler);
+        unbindMouseMoveRef.current = () => {
+          doc.removeEventListener("mousemove", handler);
+        };
+        return;
+      }
+      const shouldClose = pointerTypeRef.current === "touch" ? !(0, import_utils.contains)(elements.floating, event.relatedTarget) : true;
+      if (shouldClose) {
+        closeWithDelay(event);
+      }
+    }
+    function onScrollMouseLeave(event) {
+      if (isClickLikeOpenEvent()) return;
+      if (context.triggerElements?.hasElement(event.relatedTarget)) {
+        return;
+      }
+      const placement = dataRef.current.placement || "bottom";
+      const reference2 = elements.domReference;
+      const floating = elements.floating;
+      if (!reference2 || !floating) return;
+      handleCloseRef.current?.({
+        x: event.clientX,
+        y: event.clientY,
+        placement,
+        elements: {
+          reference: reference2,
+          floating,
+          domReference: reference2
+        },
+        onClose() {
+          clearPointerEvents();
+          cleanupMouseMoveHandler();
+          if (!isClickLikeOpenEvent()) {
+            closeWithDelay(event);
+          }
+        }
+      })(event);
+    }
+    function onFloatingMouseEnter() {
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+    }
+    function onFloatingMouseLeave(event) {
+      if (isClickLikeOpenEvent()) return;
+      if (context.triggerElements?.hasElement(event.relatedTarget)) {
+        return;
+      }
+      closeWithDelay(event, false);
+    }
+    if ((0, import_utils.isElement)(elements.domReference)) {
+      const reference2 = elements.domReference;
+      const floating = elements.floating;
+      if (open) {
+        reference2.addEventListener("mouseleave", onScrollMouseLeave);
+      }
+      if (move) {
+        reference2.addEventListener("mousemove", onReferenceMouseEnter, {
+          once: true
+        });
+      }
+      reference2.addEventListener("mouseenter", onReferenceMouseEnter);
+      reference2.addEventListener("mouseleave", onReferenceMouseLeave);
+      if (floating) {
+        floating.addEventListener("mouseleave", onScrollMouseLeave);
+        floating.addEventListener("mouseenter", onFloatingMouseEnter);
+        floating.addEventListener("mouseleave", onFloatingMouseLeave);
+      }
+      return () => {
+        if (open) {
+          reference2.removeEventListener("mouseleave", onScrollMouseLeave);
+        }
+        if (move) {
+          reference2.removeEventListener("mousemove", onReferenceMouseEnter);
+        }
+        reference2.removeEventListener("mouseenter", onReferenceMouseEnter);
+        reference2.removeEventListener("mouseleave", onReferenceMouseLeave);
+        if (floating) {
+          floating.removeEventListener("mouseleave", onScrollMouseLeave);
+          floating.removeEventListener("mouseenter", onFloatingMouseEnter);
+          floating.removeEventListener("mouseleave", onFloatingMouseLeave);
+        }
+        cleanupMouseMoveHandler();
+      };
+    }
+  }, [elements, enabled, context, mouseOnly, move, open, dataRef]);
+  React.useLayoutEffect(() => {
+    if (!enabled) return;
+    if (open && handleCloseRef.current?.__options?.blockPointerEvents && isHoverOpen()) {
+      performedPointerEventsMutationRef.current = true;
+      const floatingEl = elements.floating;
+      if ((0, import_utils.isElement)(elements.domReference) && floatingEl) {
+        const body = (0, import_utils.getDocument)(elements.floating).body;
+        body.setAttribute(safePolygonIdentifier, "");
+        const ref = elements.domReference;
+        body.style.pointerEvents = "none";
+        ref.style.pointerEvents = "auto";
+        floatingEl.style.pointerEvents = "auto";
+        return () => {
+          body.style.pointerEvents = "";
+          ref.style.pointerEvents = "";
+          floatingEl.style.pointerEvents = "";
+        };
+      }
+    }
+  }, [enabled, open, elements, isHoverOpen]);
+  React.useLayoutEffect(() => {
+    if (!open) {
+      pointerTypeRef.current = void 0;
+      restTimeoutPendingRef.current = false;
+      cleanupMouseMoveHandler();
+      clearPointerEvents();
+    }
+  }, [open]);
+  React.useEffect(() => {
+    return () => {
+      cleanupMouseMoveHandler();
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+      (0, import_utils.clearTimeoutIfSet)(restTimeoutRef);
+      clearPointerEvents();
+    };
+  }, [enabled, elements.domReference]);
+  const reference = React.useMemo(() => {
+    function setPointerRef(event) {
+      pointerTypeRef.current = event.pointerType;
+    }
+    return {
+      onPointerDown: setPointerRef,
+      onPointerEnter: setPointerRef,
+      onMouseMove(event) {
+        const {
+          nativeEvent
+        } = event;
+        function handleMouseMove() {
+          if (!blockMouseMoveRef.current && !openRef.current) {
+            stableOnOpenChange(true, nativeEvent, "hover");
+          }
+        }
+        if (mouseOnly && !(0, import_utils.isMouseLikePointerType)(pointerTypeRef.current)) {
+          return;
+        }
+        if (open || restMsRef.current === 0) {
+          return;
+        }
+        if (restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2) {
+          return;
+        }
+        (0, import_utils.clearTimeoutIfSet)(restTimeoutRef);
+        if (pointerTypeRef.current === "touch") {
+          handleMouseMove();
+        } else {
+          restTimeoutPendingRef.current = true;
+          restTimeoutRef.current = window.setTimeout(handleMouseMove, restMsRef.current);
+        }
+      }
+    };
+  }, [mouseOnly, open]);
+  return React.useMemo(() => enabled ? {
+    reference
+  } : {}, [enabled, reference]);
+}