Make submenu properly size itself to fill available room and improve overlay positioning when pinch zoomed (#5660)

* progress on adding 2d flipping

* calculate max height of overlays using the overlay bottom instead of the trigger top

in the submenu case, the offset of the menu means we need to calculate the max height with respect to the overlay bottom not the trigger itself. Use overlay size instead of position so that we dont run into complexities with if we are receiving "bottom" or "top" as overlay coords

* fix some tests

* fix more tests

needed to refine the getDelta logic so that the popover position would be properly adjusted when top/bottom were outside the boundary and maxHeight wouldnt be adjusted to prevent that

* todo: question about what the actual behavior should be

* bounding the max height by the height of the boundary

* getting rid of flip and fixed edge flip code

mimic MacOS in how the submenus will simply be pushed up/down if they would exceed the boundary

* update left bottom postion tests

maxheight for leftbottom is calculated to the top of the boundary

* fixing remaining test

* some cleanup of old logic

* missed some last cleanup

* Fix overlay positioning when the boundary has been scrolled

* fix max height calc and Safari overlay positioning when already pinch zoomed in

* accidentally deleted too much

* forgot a set of parens ugh

* fix examples where triggers are placed at the bottom of the page and are scrolled into view

* this works, but why...

* fix logic

* update copy

---------

Co-authored-by: Kyle Taborski <ktabors@yahoo.com>
Co-authored-by: Robert Snow <rsnow@adobe.com>

Author: 3 people

.storybook/custom-addons/scrolling/index.js

@@ -2,12 +2,10 @@ import {addons, makeDecorator} from '@storybook/addons';
 import clsx from 'clsx';
 import {getQueryParams} from '@storybook/client-api';
 import React, {useEffect, useState} from 'react';
-import {useViewportSize} from '@react-aria/utils';
 
 function ScrollingDecorator(props) {
   let {children} = props;
   let [isScrolling, setScrolling] = useState(getQueryParams()?.scrolling === 'true' || false);
-  let {height: minHeight} = useViewportSize();
 
   useEffect(() => {
     let channel = addons.getChannel();
@@ -31,7 +29,7 @@ function ScrollingDecorator(props) {
     );
   } else {
     return (
-      <StoryWrapper style={{...styles, minHeight: minHeight}}>
+      <StoryWrapper style={{...styles, minHeight: '100svh'}}>
         {children}
       </StoryWrapper>
     );

packages/@react-aria/overlays/src/calculatePosition.ts

@@ -11,7 +11,7 @@
  */
 
 import {Axis, Placement, PlacementAxis, SizeAxis} from '@react-types/overlays';
-import {clamp} from '@react-aria/utils';
+import {clamp, isWebKit} from '@react-aria/utils';
 
 interface Position {
   top?: number,
@@ -61,6 +61,8 @@ interface PositionOpts {
   arrowBoundaryOffset?: number
 }
 
+type HeightGrowthDirection = 'top' | 'bottom';
+
 export interface PositionResult {
   position?: Position,
   arrowOffsetLeft?: number,
@@ -106,16 +108,24 @@ let visualViewport = typeof document !== 'undefined' && window.visualViewport;
 function getContainerDimensions(containerNode: Element): Dimensions {
   let width = 0, height = 0, totalWidth = 0, totalHeight = 0, top = 0, left = 0;
   let scroll: Position = {};
+  let isPinchZoomedIn = visualViewport?.scale > 1;
 
   if (containerNode.tagName === 'BODY') {
     let documentElement = document.documentElement;
     totalWidth = documentElement.clientWidth;
     totalHeight = documentElement.clientHeight;
     width = visualViewport?.width ?? totalWidth;
     height = 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 (visualViewport) {
+      top = visualViewport.offsetTop;
+      left = visualViewport.offsetLeft;
+    }
   } else {
     ({width, height, top, left} = getOffset(containerNode));
     scroll.top = containerNode.scrollTop;
@@ -124,6 +134,17 @@ function getContainerDimensions(containerNode: Element): Dimensions {
     totalHeight = height;
   }
 
+  if (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 = visualViewport.pageTop;
+    left = visualViewport.pageLeft;
+  }
+
   return {width, height, totalWidth, totalHeight, scroll, top, left};
 }
 
@@ -136,6 +157,7 @@ function getScroll(node: Element): Offset {
   };
 }
 
+// Determines the amount of space required when moving the overlay to ensure it remains in the boundary
 function getDelta(
   axis: Axis,
   offset: number,
@@ -149,17 +171,25 @@ function getDelta(
   // is portaled somewhere other than the body and has an ancestor with
   // position: relative/absolute, it will be different.
   containerDimensions: Dimensions,
-  padding: number
+  padding: number,
+  containerOffsetWithBoundary: Offset
 ) {
   let containerScroll = containerDimensions.scroll[axis];
-  let boundaryHeight = boundaryDimensions[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[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[AXIS[axis]] + padding;
+  let boundaryEndEdge = boundarySize + boundaryDimensions.scroll[AXIS[axis]] - padding;
+  let startEdgeOffset = offset - containerScroll + containerOffsetWithBoundary[axis] - boundaryDimensions[AXIS[axis]];
+  let endEdgeOffset = offset - containerScroll + size + containerOffsetWithBoundary[axis] - boundaryDimensions[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;
   }
@@ -222,7 +252,7 @@ function computePosition(
   }/* else {
     the overlay top should match the button top
   } */
-  // add the crossOffset from props
+
   position[crossAxis] += crossOffset;
 
   // overlay top overlapping arrow with button bottom
@@ -242,31 +272,37 @@ function computePosition(
   } else {
     position[axis] = Math.floor(childOffset[axis] + childOffset[size] + offset);
   }
-
   return position;
 }
 
 function getMaxHeight(
   position: Position,
   boundaryDimensions: Dimensions,
   containerOffsetWithBoundary: Offset,
-  childOffset: Offset,
+  isContainerPositioned: boolean,
   margins: Position,
-  padding: number
+  padding: number,
+  overlayHeight: number,
+  heightGrowthDirection: HeightGrowthDirection
 ) {
-  return position.top != null
+  const containerHeight = (isContainerPositioned ? containerOffsetWithBoundary.height : boundaryDimensions[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,
+    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
+      - overlayTop // this is the top of the overlay
       - (margins.top + margins.bottom + padding) // save additional space for margin and padding
     )
-    // We want the distance between the top of the trigger to the top of the boundary
+    // We want the distance between the bottom of the overlay to the top of the boundary
     : Math.max(0,
-      (childOffset.top + containerOffsetWithBoundary.top) // this is the top of the trigger
+      (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 getAvailableSpace(
@@ -337,16 +373,34 @@ export function calculatePositionInternal(
     }
   }
 
-  let delta = 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: 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 = getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
   position[crossAxis] += delta;
 
   let maxHeight = getMaxHeight(
     position,
     boundaryDimensions,
     containerOffsetWithBoundary,
-    childOffset,
+    isContainerPositioned,
     margins,
-    padding
+    padding,
+    overlaySize.height,
+    heightGrowthDirection
   );
 
   if (userSetMaxHeight && userSetMaxHeight < maxHeight) {
@@ -356,7 +410,7 @@ export function calculatePositionInternal(
   overlaySize.height = Math.min(overlaySize.height, maxHeight);
 
   position = computePosition(childOffset, boundaryDimensions, overlaySize, placementInfo, normalizedOffset, crossOffset, containerOffsetWithBoundary, isContainerPositioned, arrowSize, arrowBoundaryOffset);
-  delta = getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding);
+  delta = getDelta(crossAxis, position[crossAxis], overlaySize[crossSize], boundaryDimensions, containerDimensions, padding, containerOffsetWithBoundary);
   position[crossAxis] += delta;
 
   let arrowPosition: Position = {};
@@ -425,7 +479,14 @@ export function calculatePosition(opts: PositionOpts): PositionResult {
   let scrollSize = getScroll(scrollNode);
   let boundaryDimensions = getContainerDimensions(boundaryElement);
   let containerDimensions = 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: Offset = boundaryElement.tagName === 'BODY' ? getOffset(container) : getPosition(container, boundaryElement);
+  if (container.tagName === 'HTML' && boundaryElement.tagName === 'BODY') {
+    containerDimensions.scroll.top = 0;
+    containerDimensions.scroll.left = 0;
+  }
 
   return calculatePositionInternal(
     placement,

packages/@react-aria/overlays/test/calculatePosition.test.ts

@@ -99,7 +99,9 @@ const PROVIDER_OFFSET = 50;
 
 describe('calculatePosition', function () {
   function checkPositionCommon(title, expected, placement, targetDimension, boundaryDimensions, offset, crossOffset, flip, providerOffset = 0, arrowSize = 8, arrowBoundaryOffset = 0) {
-    const placementAxis = placement.split(' ')[0];
+    let placementArray = placement.split(' ');
+    const placementAxis = placementArray[0];
+    const placementCrossAxis = placementArray[1];
 
     // The tests are all based on top/left positioning. Convert to bottom/right positioning if needed.
     let pos: {right?: number, top?: number, left?: number, bottom?: number} = {};
@@ -121,7 +123,8 @@ describe('calculatePosition', function () {
       position: pos,
       arrowOffsetLeft: expected[2],
       arrowOffsetTop: expected[3],
-      maxHeight: expected[4] - (placementAxis !== 'top' ? providerOffset : 0),
+      // Note that a crossAxis of 'bottom' indicates that the overlay grows towards the top since the bottom of the overlay aligns with the bottom of the trigger
+      maxHeight: expected[4] - (placementAxis !== 'top' && placementCrossAxis !== 'bottom' ? providerOffset : 0),
       placement: flip ? FLIPPED_DIRECTION[placementAxis] : placementAxis
     };
 
@@ -216,13 +219,13 @@ describe('calculatePosition', function () {
     },
     {
       placement: 'left bottom',
-      noOffset: [50, 150, undefined, 196, 400],
-      offsetBefore: [-200, 50, undefined, 50, 500],
-      offsetAfter: [300, 350, undefined, 196, 200],
-      crossAxisOffsetPositive: [50, 160, undefined, 196, 390],
-      crossAxisOffsetNegative: [50, 140, undefined, 196, 410],
-      mainAxisOffset: [40, 150, undefined, 196, 400],
-      arrowBoundaryOffset: [50, 322, undefined, 176, 228]
+      noOffset: [50, 150, undefined, 196, 300],
+      offsetBefore: [-200, 50, undefined, 50, 200],
+      offsetAfter: [300, 350, undefined, 196, 500],
+      crossAxisOffsetPositive: [50, 160, undefined, 196, 310],
+      crossAxisOffsetNegative: [50, 140, undefined, 196, 290],
+      mainAxisOffset: [40, 150, undefined, 196, 300],
+      arrowBoundaryOffset: [50, 322, undefined, 176, 472]
     },
     {
       placement: 'top',
@@ -231,7 +234,7 @@ describe('calculatePosition', function () {
       offsetAfter: [350, 300, 196, undefined, 450],
       crossAxisOffsetPositive: [210, 50, 196, undefined, 200],
       crossAxisOffsetNegative: [190, 50, 196, undefined, 200],
-      mainAxisOffset: [200, 40, 196, undefined, 200],
+      mainAxisOffset: [200, 40, 196, undefined, 190],
       arrowBoundaryOffset: [322, 50, 176, undefined, 200]
     },
     {
@@ -241,7 +244,7 @@ describe('calculatePosition', function () {
       offsetAfter: [350, 300, 196, undefined, 450],
       crossAxisOffsetPositive: [260, 50, 196, undefined, 200],
       crossAxisOffsetNegative: [240, 50, 196, undefined, 200],
-      mainAxisOffset: [250, 40, 196, undefined, 200],
+      mainAxisOffset: [250, 40, 196, undefined, 190],
       arrowBoundaryOffset: [322, 50, 176, undefined, 200]
     },
     {
@@ -251,7 +254,7 @@ describe('calculatePosition', function () {
       offsetAfter: [350, 300, 196, undefined, 450],
       crossAxisOffsetPositive: [160, 50, 196, undefined, 200],
       crossAxisOffsetNegative: [140, 50, 196, undefined, 200],
-      mainAxisOffset: [150, 40, 196, undefined, 200],
+      mainAxisOffset: [150, 40, 196, undefined, 190],
       arrowBoundaryOffset: [322, 50, 176, undefined, 200]
     },
     {
@@ -306,13 +309,13 @@ describe('calculatePosition', function () {
     },
     {
       placement: 'right bottom',
-      noOffset: [350, 150, undefined, 196, 400],
-      offsetBefore: [100, 50, undefined, 50, 500],
-      offsetAfter: [600, 350, undefined, 196, 200],
-      crossAxisOffsetPositive: [350, 160, undefined, 196, 390],
-      crossAxisOffsetNegative: [350, 140, undefined, 196, 410],
-      mainAxisOffset: [360, 150, undefined, 196, 400],
-      arrowBoundaryOffset: [350, 322, undefined, 176, 228]
+      noOffset: [350, 150, undefined, 196, 300],
+      offsetBefore: [100, 50, undefined, 50, 200],
+      offsetAfter: [600, 350, undefined, 196, 500],
+      crossAxisOffsetPositive: [350, 160, undefined, 196, 310],
+      crossAxisOffsetNegative: [350, 140, undefined, 196, 290],
+      mainAxisOffset: [360, 150, undefined, 196, 300],
+      arrowBoundaryOffset: [350, 322, undefined, 176, 472]
     }
   ];