@sanity/ui 0.37.14-next.6 → 0.37.16

package/src/primitives/popover/popover.tsx

@@ -1,30 +1,25 @@
-import {
-  Middleware,
-  arrow,
-  autoUpdate,
-  flip,
-  offset,
-  shift,
-  useFloating,
-  size as sizeMiddleware,
-  RootBoundary,
-} from '@floating-ui/react-dom'
 import React, {
   cloneElement,
   forwardRef,
-  memo,
   useCallback,
   useEffect,
   useMemo,
   useRef,
   useState,
 } from 'react'
-import {useForwardedRef, useArrayProp, useElementSize} from '../../hooks'
+import {usePopper} from 'react-popper'
+import styled, {css} from 'styled-components'
+import {EMPTY_RECORD} from '../../constants'
+import {useArrayProp, useForwardedRef} from '../../hooks'
 import {ThemeColorSchemeKey, useTheme} from '../../theme'
-import {BoxOverflow, CardTone, Placement, PopoverMargins} from '../../types'
-import {LayerProps, LayerProvider, Portal, useBoundaryElement} from '../../utils'
+import {CardTone, Placement, PopoverMargins} from '../../types'
+import {Layer, LayerProps, Portal, useBoundaryElement, usePortal} from '../../utils'
+import {Card} from '../card'
+import {ResponsiveWidthStyleProps} from '../container'
+import {responsiveContainerWidthStyle} from '../container/styles'
 import {ResponsiveRadiusProps, ResponsiveShadowProps, ResponsiveWidthProps} from '../types'
-import {PopoverCard} from './popoverCard'
+import {PopoverArrow} from './arrow'
+import {usePopoverModifiers} from './modifiers'
 
 /**
  * @public
@@ -38,7 +33,6 @@ export interface PopoverProps
    * @beta
    */
   __unstable_margins?: PopoverMargins
-  /** @deprecated Use `fallbackPlacements` instead. */
   allowedAutoPlacements?: Placement[]
   arrow?: boolean
   boundaryElement?: HTMLElement | null
@@ -48,7 +42,6 @@ export interface PopoverProps
   disabled?: boolean
   fallbackPlacements?: Placement[]
   open?: boolean
-  overflow?: BoxOverflow
   padding?: number | number[]
   placement?: Placement
   portal?: boolean | string
@@ -56,243 +49,217 @@ export interface PopoverProps
   referenceElement?: HTMLElement | null
   matchReferenceWidth?: boolean
   scheme?: ThemeColorSchemeKey
-  /** @deprecated No longer supported. */
   tether?: boolean
-  /** @deprecated No longer supported. */
   tetherOffset?: number | ((...args: any[]) => number)
   tone?: CardTone
 }
 
-function size(scope: {
-  boundaryElement: HTMLElement | null
-  constrainSize: boolean
-  matchReferenceWidth: boolean | undefined
-  setAvailableWidth: (v: number) => void
-  setAvailableHeight: (v: number) => void
-  setReferenceWidth: (v: number) => void
-}) {
-  return sizeMiddleware({
-    apply(args) {
-      if (scope.constrainSize) {
-        scope.setAvailableWidth(args.availableWidth)
-        scope.setAvailableHeight(args.availableHeight)
-      }
-
-      if (scope.matchReferenceWidth) {
-        scope.setReferenceWidth(args.rects.reference.width)
-      }
-    },
-    boundary: scope.boundaryElement || undefined,
-  })
-}
-
-export const Popover = memo(
-  forwardRef(function Popover(
-    props: PopoverProps &
-      Omit<React.HTMLProps<HTMLDivElement>, 'as' | 'children' | 'content' | 'width'>,
-    ref: React.ForwardedRef<HTMLDivElement>
-  ): React.ReactElement {
-    const theme = useTheme()
-    const boundaryElementContext = useBoundaryElement()
-
-    const {
-      __unstable_margins: margins,
-      allowedAutoPlacements,
-      arrow: arrowProp = true,
-      boundaryElement = boundaryElementContext.element,
-      children: childProp,
-      constrainSize = false,
-      content,
-      disabled,
-      fallbackPlacements,
-      matchReferenceWidth: matchReferenceWidthProp,
-      open,
-      overflow = props.constrainSize ? 'auto' : undefined,
-      padding: paddingProp,
-      placement: placementProp = 'bottom',
-      portal,
-      preventOverflow = true,
-      radius: radiusProp = 3,
-      referenceElement,
-      scheme,
-      shadow: shadowProp = 3,
-      tether,
-      tetherOffset,
-      tone = 'inherit',
-      width: widthProp = undefined,
-      zOffset: zOffsetProp = theme.sanity.layer?.popover.zOffset,
-      ...restProps
-    } = props
-    const boundarySize = useElementSize(boundaryElement)?.border
-    const padding = useArrayProp(paddingProp)
-    const radius = useArrayProp(radiusProp)
-    const shadow = useArrayProp(shadowProp)
-    const width = useArrayProp(widthProp)
-    const zOffset = useArrayProp(zOffsetProp)
-    const [availableWidth, setAvailableWidth] = useState<number | undefined>(undefined)
-    const [availableHeight, setAvailableHeight] = useState<number | undefined>(undefined)
-    const [referenceWidth, setReferenceWidth] = useState<number | undefined>(undefined)
-    const forwardedRef = useForwardedRef(ref)
-    const arrowRef = useRef<HTMLDivElement | null>(null)
-    const rootBoundary: RootBoundary = 'viewport'
+const Root = styled(Layer)<{$preventOverflow?: boolean}>(
+  ({$preventOverflow}) => css`
+    pointer-events: none;
+    display: flex;
+    flex-direction: column;
+    max-width: calc(100% - 16px);
 
-    const middleware = useMemo(() => {
-      const ret: Middleware[] = []
+    & > * {
+      min-height: 0;
+    }
 
-      // Flip the floating element when leaving the boundary box
-      if (constrainSize || preventOverflow) {
-        ret.push(
-          flip({
-            boundary: boundaryElement || undefined,
-            fallbackPlacements,
-            padding: 8,
-            rootBoundary,
-          })
-        )
+    /* Hide the popover when the reference element is out of bounds */
+    ${$preventOverflow &&
+    css`
+      &[data-popper-reference-hidden='true'] {
+        display: none;
       }
+    `}
+  `
+)
 
-      // Track sizes
-      ret.push(
-        size({
-          boundaryElement,
-          constrainSize,
-          matchReferenceWidth: matchReferenceWidthProp,
-          setAvailableHeight,
-          setAvailableWidth,
-          setReferenceWidth,
-        })
-      )
+const PopoverCard = styled(Card)<
+  ResponsiveWidthStyleProps & {
+    $constrainSize?: boolean
+    $preventOverflow?: boolean
+    $width: (number | 'auto')[]
+  }
+>(
+  ({$constrainSize}) => css`
+    flex: 1;
+    max-height: ${$constrainSize && '100%'};
+    pointer-events: all;
 
-      // Define distance between reference and floating element
-      ret.push(offset({mainAxis: arrowProp ? 4 : 0}))
+    && {
+      display: flex;
+    }
 
-      // Shift the popover so its sits with the boundary eleement
-      if (preventOverflow) {
-        ret.push(
-          shift({
-            boundary: boundaryElement || undefined,
-            rootBoundary,
-            padding: 8,
-          })
-        )
-      }
+    flex-direction: column;
 
-      // Place arrow
-      if (arrowProp) {
-        ret.push(arrow({element: arrowRef, padding: 4}))
-      }
+    & > * {
+      min-height: 0;
+    }
 
-      return ret
-    }, [
-      arrowProp,
-      boundaryElement,
-      constrainSize,
-      fallbackPlacements,
-      matchReferenceWidthProp,
-      preventOverflow,
-    ])
+    ${responsiveContainerWidthStyle}
+  `
+)
 
-    const {x, y, placement, reference, floating, middlewareData, strategy} = useFloating({
-      middleware,
-      placement: placementProp,
-      whileElementsMounted: autoUpdate,
-    })
+/**
+ * @public
+ */
+export const Popover = forwardRef(function Popover(
+  props: PopoverProps &
+    Omit<React.HTMLProps<HTMLDivElement>, 'as' | 'children' | 'content' | 'width'>,
+  ref: React.ForwardedRef<HTMLDivElement>
+) {
+  const boundaryElementContext = useBoundaryElement()
+  const theme = useTheme()
+  const {
+    __unstable_margins: margins,
+    allowedAutoPlacements,
+    arrow = true,
+    boundaryElement: boundaryElementProp = boundaryElementContext.element,
+    children: child,
+    content,
+    constrainSize,
+    disabled,
+    fallbackPlacements,
+    open = false,
+    padding,
+    placement = 'bottom',
+    portal: portalProp = false,
+    preventOverflow,
+    radius = 3,
+    referenceElement: referenceElementProp,
+    matchReferenceWidth,
+    shadow = 3,
+    scheme,
+    style = EMPTY_RECORD,
+    tether,
+    tetherOffset,
+    tone = 'inherit',
+    width: widthProp = 0,
+    zOffset = theme.sanity.layer?.popover.zOffset,
+    ...restProps
+  } = props
+  const forwardedRef = useForwardedRef(ref)
+  const portal = usePortal()
+  const [referenceElement, setReferenceElement] = useState<HTMLElement | null>(null)
+  const [popperElement, setPopperElement] = useState<HTMLElement | null>(null)
+  const [arrowElement, setArrowElement] = useState<HTMLElement | null>(null)
+  const popperReferenceElement = referenceElementProp || referenceElement
+  const width = useArrayProp(matchReferenceWidth ? 'auto' : widthProp)
 
-    const arrowX = middlewareData.arrow?.x
-    const arrowY = middlewareData.arrow?.y
+  const modifiers = usePopoverModifiers({
+    allowedAutoPlacements,
+    arrow,
+    arrowElement,
+    boundaryElement: boundaryElementProp || portal.boundaryElement,
+    constrainSize,
+    distance: arrow ? 4 : 0,
+    fallbackPlacements,
+    margins,
+    matchReferenceWidth,
+    open,
+    preventOverflow,
+    skidding: 0,
+    tether,
+    tetherOffset,
+  })
 
-    const setArrow = useCallback((arrowEl: HTMLDivElement | null) => {
-      arrowRef.current = arrowEl
-    }, [])
+  const popper = usePopper(popperReferenceElement, popperElement, {
+    placement,
+    modifiers,
+  })
 
-    const setFloating = useCallback(
-      (node: HTMLDivElement | null) => {
-        forwardedRef.current = node
-        floating(node)
-      },
-      [floating, forwardedRef]
-    )
+  const {attributes, forceUpdate, styles} = popper
 
-    const setReference = useCallback(
-      (node: HTMLElement | null) => {
-        reference(node)
+  const setRef = useCallback(
+    (el: HTMLElement | null) => {
+      const childRef = (child as any).ref
 
-        const childRef = (childProp as any)?.ref
+      setReferenceElement(el)
 
-        if (typeof childRef === 'function') {
-          childRef(node)
-        } else if (childRef) {
-          childRef.current = node
-        }
-      },
-      [childProp, reference]
-    )
+      if (typeof childRef === 'function') {
+        childRef(el)
+      } else if (childRef) {
+        childRef.current = el
+      }
+    },
+    [child]
+  )
 
-    const child = useMemo(() => {
-      if (!childProp || referenceElement) return null
+  const setRootRef = useCallback(
+    (el: HTMLDivElement | null) => {
+      setPopperElement(el)
+      forwardedRef.current = el
+    },
+    [forwardedRef]
+  )
 
-      return cloneElement(childProp, {ref: setReference})
-    }, [childProp, referenceElement, setReference])
+  const popoverStyle = useMemo(() => ({...style, ...styles.popper}), [style, styles])
 
-    useEffect(() => {
-      if (referenceElement) reference(referenceElement)
-    }, [reference, referenceElement])
+  const updateTimeoutRef = useRef<NodeJS.Timeout | null>(null)
 
-    if (disabled) {
-      return childProp || <></>
+  useEffect(() => {
+    if (updateTimeoutRef.current) {
+      clearTimeout(updateTimeoutRef.current)
+      updateTimeoutRef.current = null
     }
 
-    const popover = (
-      <LayerProvider zOffset={zOffset}>
-        <PopoverCard
-          {...restProps}
-          __unstable_margins={margins}
-          arrow={arrowProp}
-          arrowRef={setArrow}
-          arrowX={arrowX}
-          arrowY={arrowY}
-          availableWidth={constrainSize ? availableWidth : undefined}
-          availableHeight={constrainSize ? availableHeight : undefined}
-          boundaryWidth={boundarySize?.width}
-          overflow={overflow}
-          padding={padding}
-          placement={placement}
-          radius={radius}
-          ref={setFloating}
-          referenceWidth={matchReferenceWidthProp ? referenceWidth : undefined}
-          scheme={scheme}
-          shadow={shadow}
-          strategy={strategy}
-          tone={tone}
-          x={x}
-          y={y}
-          width={width}
-        >
-          {content}
-        </PopoverCard>
-      </LayerProvider>
-    )
+    updateTimeoutRef.current = setTimeout(() => {
+      if (forceUpdate) {
+        try {
+          forceUpdate()
+        } catch (_) {
+          // ignore caught error
+        }
+      }
+    }, 0)
+  }, [content, forceUpdate, open, popperReferenceElement])
 
-    return (
-      <>
-        {/* the popover */}
-        {open && (
-          <>
-            {portal ? (
-              <Portal __unstable_name={typeof portal === 'string' ? portal : undefined}>
-                {popover}
-              </Portal>
-            ) : (
-              popover
-            )}
-          </>
-        )}
+  if (disabled) {
+    return child || <></>
+  }
 
-        {/* the referred element */}
-        {child}
-      </>
-    )
-  })
-)
+  const node = (
+    <Root
+      data-ui="Popover"
+      {...restProps}
+      $preventOverflow={preventOverflow}
+      ref={setRootRef}
+      style={popoverStyle}
+      zOffset={zOffset}
+      {...attributes.popper}
+    >
+      <PopoverCard
+        $constrainSize={constrainSize}
+        $width={width}
+        data-ui="PopoverCard"
+        padding={padding}
+        radius={radius}
+        scheme={scheme}
+        shadow={shadow}
+        tone={tone}
+      >
+        {arrow && <PopoverArrow ref={setArrowElement} style={styles.arrow} />}
+        {content}
+      </PopoverCard>
+    </Root>
+  )
+
+  return (
+    <>
+      {child && !referenceElementProp ? cloneElement(child, {ref: setRef}) : child || <></>}
+
+      {open && (
+        <>
+          {portalProp && (
+            <Portal __unstable_name={typeof portalProp === 'string' ? portalProp : undefined}>
+              {node}
+            </Portal>
+          )}
 
-Popover.displayName = 'Popover'
+          {!portalProp && node}
+        </>
+      )}
+    </>
+  )
+})

package/src/primitives/textArea/textArea.tsx

@@ -80,6 +80,7 @@ export const TextArea = forwardRef(function TextArea(
           {...restProps}
           $fontSize={useArrayProp(fontSize)}
           $padding={useArrayProp(padding)}
+          $scheme={rootTheme.scheme}
           $space={useArrayProp(0)}
           $tone={rootTheme.tone}
           $weight={weight}
@@ -89,6 +90,7 @@ export const TextArea = forwardRef(function TextArea(
         <Presentation
           $border={border}
           $radius={useArrayProp(radius)}
+          $scheme={rootTheme.scheme}
           $tone={rootTheme.tone}
           data-tone={rootTheme.tone}
         />