@react-aria/overlays 3.20.0 → 3.21.1

package/dist/module.js

@@ -32,8 +32,8 @@ import $29700c92185d38f8$exports from "./tr-TR.module.js";
 import $662ccaf2be4c25b3$exports from "./uk-UA.module.js";
 import $d80a27deda7cdb3c$exports from "./zh-CN.module.js";
 import $2b2734393847c884$exports from "./zh-TW.module.js";
-import $k7QOs$react, {useState as $k7QOs$useState, useCallback as $k7QOs$useCallback, useRef as $k7QOs$useRef, useEffect as $k7QOs$useEffect, useContext as $k7QOs$useContext, useMemo as $k7QOs$useMemo} from "react";
-import {useLayoutEffect as $k7QOs$useLayoutEffect, useResizeObserver as $k7QOs$useResizeObserver, clamp as $k7QOs$clamp, useId as $k7QOs$useId, isIOS as $k7QOs$isIOS, chain as $k7QOs$chain, getScrollParent as $k7QOs$getScrollParent, useLabels as $k7QOs$useLabels, mergeProps as $k7QOs$mergeProps} from "@react-aria/utils";
+import $k7QOs$react, {useState as $k7QOs$useState, useRef as $k7QOs$useRef, useEffect as $k7QOs$useEffect, useCallback as $k7QOs$useCallback, useContext as $k7QOs$useContext, useMemo as $k7QOs$useMemo} from "react";
+import {useLayoutEffect as $k7QOs$useLayoutEffect, useResizeObserver as $k7QOs$useResizeObserver, isWebKit as $k7QOs$isWebKit, clamp as $k7QOs$clamp, useId as $k7QOs$useId, isIOS as $k7QOs$isIOS, chain as $k7QOs$chain, getScrollParent as $k7QOs$getScrollParent, useLabels as $k7QOs$useLabels, mergeProps as $k7QOs$mergeProps} from "@react-aria/utils";
 import {useLocale as $k7QOs$useLocale, useLocalizedStringFormatter as $k7QOs$useLocalizedStringFormatter} from "@react-aria/i18n";
 import {isElementInChildOfActiveScope as $k7QOs$isElementInChildOfActiveScope, FocusScope as $k7QOs$FocusScope} from "@react-aria/focus";
 import {useInteractOutside as $k7QOs$useInteractOutside, useFocusWithin as $k7QOs$useFocusWithin, ClearPressResponder as $k7QOs$ClearPressResponder} from "@react-aria/interactions";
@@ -106,6 +106,7 @@ let $edcf132a9284368a$var$visualViewport = typeof document !== "undefined" && wi
 function $edcf132a9284368a$var$getContainerDimensions(containerNode) {
     let width = 0, height = 0, totalWidth = 0, totalHeight = 0, top = 0, left = 0;
     let scroll = {};
+    let isPinchZoomedIn = ($edcf132a9284368a$var$visualViewport === null || $edcf132a9284368a$var$visualViewport === void 0 ? void 0 : $edcf132a9284368a$var$visualViewport.scale) > 1;
     if (containerNode.tagName === "BODY") {
         let documentElement = document.documentElement;
         totalWidth = documentElement.clientWidth;
@@ -116,6 +117,13 @@ function $edcf132a9284368a$var$getContainerDimensions(containerNode) {
         height = (_visualViewport_height = $edcf132a9284368a$var$visualViewport === null || $edcf132a9284368a$var$visualViewport === void 0 ? void 0 : $edcf132a9284368a$var$visualViewport.height) !== null && _visualViewport_height !== void 0 ? _visualViewport_height : totalHeight;
         scroll.top = documentElement.scrollTop || containerNode.scrollTop;
         scroll.left = documentElement.scrollLeft || containerNode.scrollLeft;
+        // The goal of the below is to get a top/left value that represents the top/left of the visual viewport with
+        // respect to the layout viewport origin. This combined with the scrollTop/scrollLeft will allow us to calculate
+        // coordinates/values with respect to the visual viewport or with respect to the layout viewport.
+        if ($edcf132a9284368a$var$visualViewport) {
+            top = $edcf132a9284368a$var$visualViewport.offsetTop;
+            left = $edcf132a9284368a$var$visualViewport.offsetLeft;
+        }
     } else {
         ({ width: width, height: height, top: top, left: left } = $edcf132a9284368a$var$getOffset(containerNode));
         scroll.top = containerNode.scrollTop;
@@ -123,6 +131,16 @@ function $edcf132a9284368a$var$getContainerDimensions(containerNode) {
         totalWidth = width;
         totalHeight = height;
     }
+    if ((0, $k7QOs$isWebKit)() && (containerNode.tagName === "BODY" || containerNode.tagName === "HTML") && isPinchZoomedIn) {
+        // Safari will report a non-zero scrollTop/Left for the non-scrolling body/HTML element when pinch zoomed in unlike other browsers.
+        // Set to zero for parity calculations so we get consistent positioning of overlays across all browsers.
+        // Also switch to visualViewport.pageTop/pageLeft so that we still accomodate for scroll positioning for body/HTML elements that are actually scrollable
+        // before pinch zoom happens
+        scroll.top = 0;
+        scroll.left = 0;
+        top = $edcf132a9284368a$var$visualViewport.pageTop;
+        left = $edcf132a9284368a$var$visualViewport.pageLeft;
+    }
     return {
         width: width,
         height: height,
@@ -141,6 +159,7 @@ function $edcf132a9284368a$var$getScroll(node) {
         height: node.scrollHeight
     };
 }
+// Determines the amount of space required when moving the overlay to ensure it remains in the boundary
 function $edcf132a9284368a$var$getDelta(axis, offset, size, // The dimensions of the boundary element that the popover is
 // positioned within (most of the time this is the <body>).
 boundaryDimensions, // The dimensions of the containing block element that the popover is
@@ -148,13 +167,20 @@ boundaryDimensions, // The dimensions of the containing block element that the p
 // Usually this is the same as the boundary element, but if the popover
 // is portaled somewhere other than the body and has an ancestor with
 // position: relative/absolute, it will be different.
-containerDimensions, padding) {
+containerDimensions, padding, containerOffsetWithBoundary) {
     let containerScroll = containerDimensions.scroll[axis];
-    let boundaryHeight = boundaryDimensions[$edcf132a9284368a$var$AXIS_SIZE[axis]];
-    let startEdgeOffset = offset - padding - containerScroll;
-    let endEdgeOffset = offset + padding - containerScroll + size;
-    if (startEdgeOffset < 0) return -startEdgeOffset;
-    else if (endEdgeOffset > boundaryHeight) return Math.max(boundaryHeight - endEdgeOffset, -startEdgeOffset);
+    // The height/width of the boundary. Matches the axis along which we are adjusting the overlay position
+    let boundarySize = boundaryDimensions[$edcf132a9284368a$var$AXIS_SIZE[axis]];
+    // Calculate the edges of the boundary (accomodating for the boundary padding) and the edges of the overlay.
+    // Note that these values are with respect to the visual viewport (aka 0,0 is the top left of the viewport)
+    let boundaryStartEdge = boundaryDimensions.scroll[$edcf132a9284368a$var$AXIS[axis]] + padding;
+    let boundaryEndEdge = boundarySize + boundaryDimensions.scroll[$edcf132a9284368a$var$AXIS[axis]] - padding;
+    let startEdgeOffset = offset - containerScroll + containerOffsetWithBoundary[axis] - boundaryDimensions[$edcf132a9284368a$var$AXIS[axis]];
+    let endEdgeOffset = offset - containerScroll + size + containerOffsetWithBoundary[axis] - boundaryDimensions[$edcf132a9284368a$var$AXIS[axis]];
+    // If any of the overlay edges falls outside of the boundary, shift the overlay the required amount to align one of the overlay's
+    // edges with the closest boundary edge.
+    if (startEdgeOffset < boundaryStartEdge) return boundaryStartEdge - startEdgeOffset;
+    else if (endEdgeOffset > boundaryEndEdge) return Math.max(boundaryEndEdge - endEdgeOffset, boundaryStartEdge - startEdgeOffset);
     else return 0;
 }
 function $edcf132a9284368a$var$getMargins(node) {
@@ -198,7 +224,6 @@ function $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions,
      /* else {
     the overlay top should match the button top
   } */ 
-    // add the crossOffset from props
     position[crossAxis] += crossOffset;
     // overlay top overlapping arrow with button bottom
     const minPosition = childOffset[crossAxis] - overlaySize[crossSize] + arrowSize + arrowBoundaryOffset;
@@ -216,14 +241,20 @@ function $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions,
     } else position[axis] = Math.floor(childOffset[axis] + childOffset[size] + offset);
     return position;
 }
-function $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding) {
-    return position.top != null ? Math.max(0, boundaryDimensions.height + boundaryDimensions.top + boundaryDimensions.scroll.top // this is the bottom of the boundary
-     - (containerOffsetWithBoundary.top + position.top // this is the top of the overlay
-    ) - (margins.top + margins.bottom + padding // save additional space for margin and padding
-    )) : Math.max(0, childOffset.top + containerOffsetWithBoundary.top // this is the top of the trigger
+function $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, isContainerPositioned, margins, padding, overlayHeight, heightGrowthDirection) {
+    const containerHeight = isContainerPositioned ? containerOffsetWithBoundary.height : boundaryDimensions[$edcf132a9284368a$var$TOTAL_SIZE.height];
+    // For cases where position is set via "bottom" instead of "top", we need to calculate the true overlay top with respect to the boundary. Reverse calculate this with the same method
+    // used in computePosition.
+    let overlayTop = position.top != null ? containerOffsetWithBoundary.top + position.top : containerOffsetWithBoundary.top + (containerHeight - position.bottom - overlayHeight);
+    let maxHeight = heightGrowthDirection !== "top" ? // We want the distance between the top of the overlay to the bottom of the boundary
+    Math.max(0, boundaryDimensions.height + boundaryDimensions.top + boundaryDimensions.scroll.top // this is the bottom of the boundary
+     - overlayTop // this is the top of the overlay
+     - (margins.top + margins.bottom + padding // save additional space for margin and padding
+    )) : Math.max(0, overlayTop + overlayHeight // this is the bottom of the overlay
      - (boundaryDimensions.top + boundaryDimensions.scroll.top // this is the top of the boundary
     ) - (margins.top + margins.bottom + padding // save additional space for margin and padding
     ));
+    return Math.min(boundaryDimensions.height - padding * 2, maxHeight);
 }
 function $edcf132a9284368a$var$getAvailableSpace(boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding, placementInfo) {
     let { placement: placement, axis: axis, size: size } = placementInfo;
@@ -248,13 +279,22 @@ function $edcf132a9284368a$export$6839422d1f33cee9(placementInput, childOffset,
             normalizedOffset = offset;
         }
     }
-    let delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding);
+    // Determine the direction the height of the overlay can grow so that we can choose how to calculate the max height
+    let heightGrowthDirection = "bottom";
+    if (placementInfo.axis === "top") {
+        if (placementInfo.placement === "top") heightGrowthDirection = "top";
+        else if (placementInfo.placement === "bottom") heightGrowthDirection = "bottom";
+    } else if (placementInfo.crossAxis === "top") {
+        if (placementInfo.crossPlacement === "top") heightGrowthDirection = "bottom";
+        else if (placementInfo.crossPlacement === "bottom") heightGrowthDirection = "top";
+    }
+    let delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
     position[crossAxis] += delta;
-    let maxHeight = $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, childOffset, margins, padding);
+    let maxHeight = $edcf132a9284368a$var$getMaxHeight(position, boundaryDimensions, containerOffsetWithBoundary, isContainerPositioned, margins, padding, overlaySize.height, heightGrowthDirection);
     if (userSetMaxHeight && userSetMaxHeight < maxHeight) maxHeight = userSetMaxHeight;
     overlaySize.height = Math.min(overlaySize.height, maxHeight);
     position = $edcf132a9284368a$var$computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, normalizedOffset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
-    delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding);
+    delta = $edcf132a9284368a$var$getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
     position[crossAxis] += delta;
     let arrowPosition = {};
     // All values are transformed so that 0 is at the top/left of the overlay depending on the orientation
@@ -296,7 +336,14 @@ function $edcf132a9284368a$export$b3ceb0cbf1056d98(opts) {
     let scrollSize = $edcf132a9284368a$var$getScroll(scrollNode);
     let boundaryDimensions = $edcf132a9284368a$var$getContainerDimensions(boundaryElement);
     let containerDimensions = $edcf132a9284368a$var$getContainerDimensions(container);
+    // If the container is the HTML element wrapping the body element, the retrieved scrollTop/scrollLeft will be equal to the
+    // body element's scroll. Set the container's scroll values to 0 since the overlay's edge position value in getDelta don't then need to be further offset
+    // by the container scroll since they are essentially the same containing element and thus in the same coordinate system
     let containerOffsetWithBoundary = boundaryElement.tagName === "BODY" ? $edcf132a9284368a$var$getOffset(container) : $edcf132a9284368a$var$getPosition(container, boundaryElement);
+    if (container.tagName === "HTML" && boundaryElement.tagName === "BODY") {
+        containerDimensions.scroll.top = 0;
+        containerDimensions.scroll.left = 0;
+    }
     return $edcf132a9284368a$export$6839422d1f33cee9(placement, childOffset, overlaySize, scrollSize, margins, padding, shouldFlip, boundaryDimensions, containerDimensions, containerOffsetWithBoundary, offset, crossOffset, isContainerPositioned, maxHeight, arrowSize, arrowBoundaryOffset);
 }
 function $edcf132a9284368a$var$getOffset(node) {
@@ -432,8 +479,21 @@ function $2a41e45df1593e64$export$d39e1813b3bdd0e1(props) {
         arrowBoundaryOffset,
         arrowSize
     ];
+    // Note, the position freezing breaks if body sizes itself dynamicly with the visual viewport but that might
+    // just be a non-realistic use case
+    // Upon opening a overlay, record the current visual viewport scale so we can freeze the overlay styles
+    let lastScale = (0, $k7QOs$useRef)($2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.scale);
+    (0, $k7QOs$useEffect)(()=>{
+        if (isOpen) lastScale.current = $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.scale;
+    }, [
+        isOpen
+    ]);
     let updatePosition = (0, $k7QOs$useCallback)(()=>{
         if (shouldUpdatePosition === false || !isOpen || !overlayRef.current || !targetRef.current || !scrollRef.current || !boundaryElement) return;
+        if (($2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.scale) !== lastScale.current) return;
+        // Always reset the overlay's previous max height if not defined by the user so that we can compensate for
+        // RAC collections populating after a second render and properly set a correct max height + positioning when it populates.
+        if (!maxHeight && overlayRef.current) overlayRef.current.style.maxHeight = "none";
         let position = (0, $edcf132a9284368a$export$b3ceb0cbf1056d98)({
             placement: $2a41e45df1593e64$var$translateRTL(placement, direction),
             overlayNode: overlayRef.current,
@@ -479,11 +539,16 @@ function $2a41e45df1593e64$export$d39e1813b3bdd0e1(props) {
             }, 500);
             updatePosition();
         };
+        // Only reposition the overlay if a scroll event happens immediately as a result of resize (aka the virtual keyboard has appears)
+        // We don't want to reposition the overlay if the user has pinch zoomed in and is scrolling the viewport around.
+        let onScroll = ()=>{
+            if (isResizing.current) onResize();
+        };
         $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.addEventListener("resize", onResize);
-        $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.addEventListener("scroll", onResize);
+        $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.addEventListener("scroll", onScroll);
         return ()=>{
             $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.removeEventListener("resize", onResize);
-            $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.removeEventListener("scroll", onResize);
+            $2a41e45df1593e64$var$visualViewport === null || $2a41e45df1593e64$var$visualViewport === void 0 ? void 0 : $2a41e45df1593e64$var$visualViewport.removeEventListener("scroll", onScroll);
         };
     }, [
         updatePosition