@banyan_cloud/roots 2.0.64 → 2.0.66

package/dist/cjs/index.js

@@ -8466,6 +8466,208 @@ function getChildren(nodes, id) {
   return allChildren;
 }
 
+function isPointInPolygon(point, polygon) {
+  const [x, y] = point;
+  let isInside = false;
+  const length = polygon.length;
+
+  for (let i = 0, j = length - 1; i < length; j = i++) {
+    const [xi, yi] = polygon[i] || [0, 0];
+    const [xj, yj] = polygon[j] || [0, 0];
+    const intersect = yi >= y !== yj >= y && x <= (xj - xi) * (y - yi) / (yj - yi) + xi;
+
+    if (intersect) {
+      isInside = !isInside;
+    }
+  }
+
+  return isInside;
+}
+
+function safePolygon(_temp) {
+  let {
+    restMs = 0,
+    buffer = 0.5,
+    blockPointerEvents = true,
+    debug = null
+  } = _temp === void 0 ? {} : _temp;
+  let timeoutId;
+  let polygonIsDestroyed = false;
+
+  const fn = _ref => {
+    let {
+      x,
+      y,
+      placement,
+      refs,
+      onClose,
+      nodeId,
+      tree,
+      leave = false
+    } = _ref;
+    return function onPointerMove(event) {
+      var _refs$domReference$cu, _refs$floating$curren, _refs$floating$curren2;
+
+      clearTimeout(timeoutId);
+
+      function close() {
+        clearTimeout(timeoutId);
+        onClose();
+      }
+
+      if (event.pointerType && event.pointerType !== 'mouse') {
+        return;
+      }
+
+      const {
+        clientX,
+        clientY
+      } = event;
+      const target = 'composedPath' in event ? event.composedPath()[0] : event.target;
+      const targetNode = target; // If the pointer is over the reference, there is no need to run the logic
+
+      if (event.type === 'pointermove' && (_refs$domReference$cu = refs.domReference.current) != null && _refs$domReference$cu.contains(targetNode)) {
+        return;
+      } // Prevent overlapping floating element from being stuck in an open-close
+      // loop: https://github.com/floating-ui/floating-ui/issues/1910
+
+
+      if (event.type === 'mouseleave' && isElement(event.relatedTarget) && (_refs$floating$curren = refs.floating.current) != null && _refs$floating$curren.contains(event.relatedTarget)) {
+        return;
+      } // If any nested child is open, abort.
+
+
+      if (tree && getChildren(tree.nodesRef.current, nodeId).some(_ref2 => {
+        let {
+          context
+        } = _ref2;
+        return context == null ? void 0 : context.open;
+      })) {
+        return;
+      } // The cursor landed, so we destroy the polygon logic
+
+
+      if ((_refs$floating$curren2 = refs.floating.current) != null && _refs$floating$curren2.contains(targetNode) && !leave) {
+        polygonIsDestroyed = true;
+        return;
+      }
+
+      if (!refs.domReference.current || !refs.floating.current || placement == null || x == null || y == null) {
+        return;
+      }
+
+      const refRect = refs.domReference.current.getBoundingClientRect();
+      const rect = refs.floating.current.getBoundingClientRect();
+      const side = placement.split('-')[0];
+      const cursorLeaveFromRight = x > rect.right - rect.width / 2;
+      const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2; // If the pointer is leaving from the opposite side, the "buffer" logic
+      // creates a point where the floating element remains open, but should be
+      // ignored.
+      // A constant of 1 handles floating point rounding errors.
+
+      if (side === 'top' && y >= refRect.bottom - 1 || side === 'bottom' && y <= refRect.top + 1 || side === 'left' && x >= refRect.right - 1 || side === 'right' && x <= refRect.left + 1) {
+        return close();
+      } // Ignore when the cursor is within the rectangular trough between the
+      // two elements. Since the triangle is created from the cursor point,
+      // which can start beyond the ref element's edge, traversing back and
+      // forth from the ref to the floating element can cause it to close. This
+      // ensures it always remains open in that case.
+
+
+      switch (side) {
+        case 'top':
+          if (clientX >= rect.left && clientX <= rect.right && clientY >= rect.top && clientY <= refRect.top + 1) {
+            return;
+          }
+
+          break;
+
+        case 'bottom':
+          if (clientX >= rect.left && clientX <= rect.right && clientY >= refRect.bottom - 1 && clientY <= rect.bottom) {
+            return;
+          }
+
+          break;
+
+        case 'left':
+          if (clientX >= rect.left && clientX <= refRect.left + 1 && clientY >= rect.top && clientY <= rect.bottom) {
+            return;
+          }
+
+          break;
+
+        case 'right':
+          if (clientX >= refRect.right - 1 && clientX <= rect.right && clientY >= rect.top && clientY <= rect.bottom) {
+            return;
+          }
+
+          break;
+      }
+
+      if (polygonIsDestroyed) {
+        return close();
+      }
+
+      function getPolygon(_ref3) {
+        let [x, y] = _ref3;
+        const isFloatingWider = rect.width > refRect.width;
+        const isFloatingTaller = rect.height > refRect.height;
+
+        switch (side) {
+          case 'top':
+            {
+              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];
+              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y + buffer + 1];
+              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.bottom - buffer : isFloatingWider ? rect.bottom - buffer : rect.top], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.bottom - buffer : rect.top : rect.bottom - buffer]];
+              return [cursorPointOne, cursorPointTwo, ...commonPoints];
+            }
+
+          case 'bottom':
+            {
+              const cursorPointOne = [isFloatingWider ? x + buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];
+              const cursorPointTwo = [isFloatingWider ? x - buffer / 2 : cursorLeaveFromRight ? x + buffer * 4 : x - buffer * 4, y - buffer];
+              const commonPoints = [[rect.left, cursorLeaveFromRight ? rect.top + buffer : isFloatingWider ? rect.top + buffer : rect.bottom], [rect.right, cursorLeaveFromRight ? isFloatingWider ? rect.top + buffer : rect.bottom : rect.top + buffer]];
+              return [cursorPointOne, cursorPointTwo, ...commonPoints];
+            }
+
+          case 'left':
+            {
+              const cursorPointOne = [x + buffer + 1, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const cursorPointTwo = [x + buffer + 1, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const commonPoints = [[cursorLeaveFromBottom ? rect.right - buffer : isFloatingTaller ? rect.right - buffer : rect.left, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.right - buffer : rect.left : rect.right - buffer, rect.bottom]];
+              return [...commonPoints, cursorPointOne, cursorPointTwo];
+            }
+
+          case 'right':
+            {
+              const cursorPointOne = [x - buffer, isFloatingTaller ? y + buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const cursorPointTwo = [x - buffer, isFloatingTaller ? y - buffer / 2 : cursorLeaveFromBottom ? y + buffer * 4 : y - buffer * 4];
+              const commonPoints = [[cursorLeaveFromBottom ? rect.left + buffer : isFloatingTaller ? rect.left + buffer : rect.right, rect.top], [cursorLeaveFromBottom ? isFloatingTaller ? rect.left + buffer : rect.right : rect.left + buffer, rect.bottom]];
+              return [cursorPointOne, cursorPointTwo, ...commonPoints];
+            }
+        }
+      }
+
+      const poly = getPolygon([x, y]);
+
+      if (process.env.NODE_ENV !== "production") {
+        debug == null ? void 0 : debug(poly.slice(0, 4).join(', '));
+      }
+
+      if (!isPointInPolygon([clientX, clientY], poly)) {
+        close();
+      } else if (restMs) {
+        timeoutId = setTimeout(onClose, restMs);
+      }
+    };
+  };
+
+  fn.__options = {
+    blockPointerEvents
+  };
+  return fn;
+}
+
 const DEFAULT_ID = 'floating-ui-root';
 const useFloatingPortalNode = function (_temp) {
   let {
@@ -14632,7 +14834,7 @@ var Tooltip = /*#__PURE__*/React.forwardRef(function (props, propRef) {
   // Event listeners to change the open state
   var hover = useHover(context, {
     move: true,
-    enabled: !clickOutsideToClose
+    handleClose: clickOutsideToClose ? safePolygon() : undefined
   });
   var focus = useFocus(context, {
     enabled: !clickOutsideToClose