@sanity/ui 4.0.0-static.9 → 4.0.0

package/src/core/primitives/popover/__workshop__/RecursiveStory.tsx

@@ -1,69 +0,0 @@
-import {Button, Flex, LayerProvider, type Placement, Popover, useLayer} from '@sanity/ui'
-import {CARD_TONES} from '@sanity/ui/theme'
-import {useCallback, useEffect, useMemo, useRef, useState} from 'react'
-
-export default function RecursiveStory(): React.JSX.Element {
-  return (
-    <Flex align="center" height="fill" justify="center" padding={[4, 5, 6]} sizing="border">
-      <LayerProvider>
-        <RecursiveExample />
-      </LayerProvider>
-    </Flex>
-  )
-}
-
-const placements: Placement[] = ['top', 'right', 'bottom', 'left']
-
-function RecursiveExample({onClose}: {onClose?: () => void}) {
-  const [open, setOpen] = useState(false)
-  const buttonRef = useRef<HTMLButtonElement | null>(null)
-  const {isTopLayer} = useLayer()
-  const [seed] = useState(() => Math.floor(Math.random() * 4))
-  const fallbackPlacements = useMemo(() => {
-    const before = placements.slice(seed)
-    const after = placements.slice(0, seed)
-
-    return before.concat(after)
-  }, [seed])
-
-  useEffect(() => {
-    if (open === false) buttonRef.current?.focus()
-  }, [open])
-
-  useEffect(() => {
-    setTimeout(() => {
-      buttonRef.current?.focus()
-    }, 0)
-  }, [])
-
-  const handleOpen = useCallback(() => setOpen(true), [])
-  const handleClose = useCallback(() => setOpen(false), [])
-
-  const handleKeyDown = useCallback(
-    (event: React.KeyboardEvent<HTMLButtonElement>) => {
-      if (!isTopLayer) return
-      if (event.key === 'Escape' && onClose) onClose()
-    },
-    [isTopLayer, onClose],
-  )
-
-  return (
-    <Popover
-      fallbackPlacements={fallbackPlacements}
-      content={<RecursiveExample onClose={handleClose} />}
-      open={open}
-      padding={1}
-      placement={fallbackPlacements[3]}
-      portal
-      tone={CARD_TONES[seed]}
-    >
-      <Button
-        mode="bleed"
-        onKeyDown={handleKeyDown}
-        onClick={handleOpen}
-        ref={buttonRef}
-        text="Open"
-      />
-    </Popover>
-  )
-}

package/src/core/primitives/popover/__workshop__/SidePanelStory.tsx

@@ -1,96 +0,0 @@
-import {
-  BoundaryElementProvider,
-  Box,
-  Card,
-  Flex,
-  Popover,
-  type PopoverProps,
-  type PopoverUpdateCallback,
-  Stack,
-  Text,
-} from '@sanity/ui'
-import type {CardTone} from '@sanity/ui/theme'
-import {useSelect} from '@sanity/ui-workshop'
-import {useCallback, useEffect, useRef, useState} from 'react'
-
-import {WORKSHOP_CARD_TONE_OPTIONS} from '$workshop'
-
-const SIDE_PANEL_WIDTH = {
-  sm: 300,
-  md: 400,
-  lg: 500,
-  xl: 600,
-}
-
-export default function SidePanelStory(): React.JSX.Element {
-  const sidePanelWidth = useSelect('Side panel width', SIDE_PANEL_WIDTH, SIDE_PANEL_WIDTH.md)
-  const [sidePanel, setSidePanel] = useState<HTMLDivElement | null>(null)
-  const updateRef = useRef<PopoverUpdateCallback>(undefined)
-  const tone = useSelect('Tone', WORKSHOP_CARD_TONE_OPTIONS) ?? 'inherit'
-
-  useEffect(() => updateRef.current?.(), [sidePanelWidth])
-
-  return (
-    <Flex height="fill">
-      <Card flex={1}>
-        <Box padding={4}>
-          <Text>
-            This story shows that popovers respect their boundary when used in a side panel.
-          </Text>
-        </Box>
-      </Card>
-      <BoundaryElementProvider element={sidePanel}>
-        <Card borderLeft flex="none" ref={setSidePanel} style={{width: sidePanelWidth}} width={0}>
-          <Stack gap={5} padding={4}>
-            <Text muted size={1}>
-              Click the <code>reference</code> text below to toggle the popover.
-            </Text>
-
-            <Card border padding={3}>
-              <Text size={1}>
-                Some editor <InlineObject tone={tone} updateRef={updateRef} />
-              </Text>
-            </Card>
-          </Stack>
-        </Card>
-      </BoundaryElementProvider>
-    </Flex>
-  )
-}
-
-function InlineObject(props: {tone: CardTone | 'inherit'; updateRef?: PopoverProps['updateRef']}) {
-  const {tone, updateRef} = props
-  const [open, setOpen] = useState(false)
-
-  const handleClick = useCallback(() => {
-    setOpen((prev) => !prev)
-  }, [])
-
-  return (
-    <Popover
-      content={
-        <Box padding={3}>
-          <Text size={1}>
-            Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum
-            has been the industry's standard dummy text ever since the 1500s, when an unknown
-            printer took a galley of type and scrambled it to make a type specimen book. It has
-            survived not only five centuries, but also the leap into electronic typesetting,
-            remaining essentially unchanged. It was popularised in the 1960s with the release of
-            Letraset sheets containing Lorem Ipsum passages, and more recently with desktop
-            publishing software like Aldus PageMaker including versions of Lorem Ipsum.
-          </Text>
-        </Box>
-      }
-      constrainSize
-      open={open}
-      overflow="auto"
-      portal
-      tone={tone}
-      width={0}
-      updateRef={updateRef}
-    >
-      {/* eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-noninteractive-element-interactions */}
-      <code onClick={handleClick}>reference</code>
-    </Popover>
-  )
-}

package/src/core/primitives/popover/__workshop__/TestStory.tsx

@@ -1,100 +0,0 @@
-import {
-  BoundaryElementProvider,
-  Button,
-  Card,
-  Popover,
-  type PopoverUpdateCallback,
-  PortalProvider,
-  Text,
-} from '@sanity/ui'
-import {useBoolean, useSelect, useText} from '@sanity/ui-workshop'
-import {useRef, useState} from 'react'
-
-import {
-  WORKSHOP_CONTAINER_WIDTH_OPTIONS,
-  WORKSHOP_PLACEMENT_OPTIONS,
-  WORKSHOP_RADIUS_OPTIONS,
-} from '$workshop'
-
-export default function TestStory(): React.JSX.Element {
-  const [portalElement, setPortalElement] = useState<HTMLDivElement | null>(null)
-  const [boundaryElement, setBoundaryElement] = useState<HTMLDivElement | null>(null)
-
-  const mount = useBoolean('Mount', true)
-  const arrow = useBoolean('Arrow', true)
-  const constrainSize = useBoolean('Constrain size', true)
-  const matchReferenceWidth = useBoolean('Match reference width', false)
-  const open = useBoolean('Open', true)
-  const placement = useSelect('Placement', WORKSHOP_PLACEMENT_OPTIONS, 'bottom')
-  const portal = useBoolean('Render in portal', true)
-  const preventOverflow = useBoolean('Prevent overflow', true)
-  const radius = useSelect('Radius', WORKSHOP_RADIUS_OPTIONS, 2)
-  const referenceWide = useBoolean('Reference wide?', false)
-  const width = useSelect('Width', WORKSHOP_CONTAINER_WIDTH_OPTIONS, 'auto')
-
-  const text = useText('Text', 'Test')
-
-  const updateRef = useRef<PopoverUpdateCallback>(undefined)
-
-  const button = (
-    <Button text="reference" selected style={{width: referenceWide ? 300 : undefined}} />
-  )
-
-  return (
-    <Card
-      ref={setBoundaryElement}
-      shadow={2}
-      style={{
-        position: 'absolute',
-        top: 50,
-        right: 50,
-        bottom: 50,
-        left: 50,
-      }}
-    >
-      <div
-        data-portal=""
-        ref={setPortalElement}
-        style={{
-          position: 'absolute',
-          top: 0,
-          right: 0,
-          bottom: 0,
-          left: 0,
-          overflow: 'hidden',
-          pointerEvents: 'none',
-        }}
-      />
-
-      <div style={{width: '100%', height: '100%', overflow: 'auto'}}>
-        <div style={{padding: '150vh'}}>
-          <PortalProvider element={portalElement}>
-            <BoundaryElementProvider element={boundaryElement}>
-              {!mount && button}
-              {mount && (
-                <Popover
-                  arrow={arrow}
-                  content={<Text size={1}>{text}</Text>}
-                  constrainSize={constrainSize}
-                  fallbackPlacements={['left', 'bottom', 'right', 'top']}
-                  matchReferenceWidth={matchReferenceWidth}
-                  open={open}
-                  overflow="hidden"
-                  padding={3}
-                  placement={placement}
-                  portal={portal}
-                  preventOverflow={preventOverflow}
-                  radius={radius}
-                  updateRef={updateRef}
-                  width={width}
-                >
-                  {button}
-                </Popover>
-              )}
-            </BoundaryElementProvider>
-          </PortalProvider>
-        </div>
-      </div>
-    </Card>
-  )
-}

package/src/core/primitives/popover/__workshop__/index.ts

@@ -1,51 +0,0 @@
-import type {WorkshopScope} from '@sanity/ui-workshop'
-import {lazy} from 'react'
-
-const scope: WorkshopScope = {
-  name: 'primitives/popover',
-  title: 'Popover',
-  stories: [
-    {
-      name: 'test',
-      title: 'Test',
-      component: lazy(() => import('./TestStory')),
-    },
-    {
-      name: 'plain',
-      title: 'Plain',
-      component: lazy(() => import('./PlainStory')),
-    },
-    {
-      name: 'recursive',
-      title: 'Recursive',
-      component: lazy(() => import('./RecursiveStory')),
-    },
-    {
-      name: 'match-ref-width',
-      title: 'Match reference width',
-      component: lazy(() => import('./MatchReferenceWidthStory')),
-    },
-    {
-      name: 'margins',
-      title: 'Margins',
-      component: lazy(() => import('./MarginsStory')),
-    },
-    {
-      name: 'aligned',
-      title: 'Aligned',
-      component: lazy(() => import('./AlignedStory')),
-    },
-    {
-      name: 'openOnMountStory',
-      title: 'Open on mount',
-      component: lazy(() => import('./OpenOnMountStory')),
-    },
-    {
-      name: 'side-panel',
-      title: 'Side panel',
-      component: lazy(() => import('./SidePanelStory')),
-    },
-  ],
-}
-
-export default scope

package/src/core/primitives/popover/constants.ts

@@ -1,22 +0,0 @@
-import type {Placement, PopoverMargins} from '@sanity/ui'
-
-export const DEFAULT_POPOVER_DISTANCE = 4
-export const DEFAULT_POPOVER_PADDING = 4
-export const DEFAULT_POPOVER_ARROW_WIDTH = 19
-export const DEFAULT_POPOVER_ARROW_HEIGHT = 8
-export const DEFAULT_POPOVER_ARROW_RADIUS = 2
-export const DEFAULT_POPOVER_MARGINS: PopoverMargins = [0, 0, 0, 0]
-export const DEFAULT_FALLBACK_PLACEMENTS: Record<Placement, Placement[]> = {
-  'top': ['bottom', 'left', 'right'],
-  'top-start': ['bottom-start', 'left-start', 'right-start'],
-  'top-end': ['bottom-end', 'left-end', 'right-end'],
-  'bottom': ['top', 'left', 'right'],
-  'bottom-start': ['top-start', 'left-start', 'right-start'],
-  'bottom-end': ['top-end', 'left-end', 'right-end'],
-  'left': ['right', 'top', 'bottom'],
-  'left-start': ['right-start', 'top-start', 'bottom-start'],
-  'left-end': ['right-end', 'top-end', 'bottom-end'],
-  'right': ['left', 'top', 'bottom'],
-  'right-start': ['left-start', 'top-start', 'bottom-start'],
-  'right-end': ['left-end', 'top-end', 'bottom-end'],
-}

package/src/core/primitives/popover/floating-ui/size.ts

@@ -1,83 +0,0 @@
-import {detectOverflow, type Elements, type Middleware} from '@floating-ui/react-dom'
-
-import type {PopoverMargins} from '../types'
-
-export interface SizeMiddlewareApplyOptions {
-  availableWidth: number
-  availableHeight: number
-  elements: Elements
-  referenceWidth: number
-}
-
-export function size(options: {
-  apply: (args: SizeMiddlewareApplyOptions) => void
-  boundaryElement?: HTMLElement | null
-  constrainSize: boolean
-  margins: PopoverMargins
-  matchReferenceWidth?: boolean
-  padding?: number
-}): Middleware {
-  const {apply, margins, padding = 0} = options
-
-  return {
-    name: '@sanity/ui/size',
-    async fn(args) {
-      const {elements, placement, platform, rects} = args
-      const {floating, reference} = rects
-
-      const overflow = await detectOverflow(args, {
-        altBoundary: true,
-        boundary: options.boundaryElement || undefined,
-        elementContext: 'floating',
-        padding,
-        rootBoundary: 'viewport',
-      })
-
-      let maxWidth = Infinity
-      let maxHeight = Infinity
-
-      const floatingW = floating.width
-      const floatingH = floating.height
-
-      if (placement.includes('top')) {
-        maxWidth = floatingW - (overflow.left + overflow.right)
-        maxHeight = floatingH - overflow.top
-      }
-
-      if (placement.includes('right')) {
-        maxWidth = floatingW - overflow.right
-        maxHeight = floatingH - (overflow.top + overflow.bottom)
-      }
-
-      if (placement.includes('bottom')) {
-        maxWidth = floatingW - (overflow.left + overflow.right)
-        maxHeight = floatingH - overflow.bottom
-      }
-
-      if (placement.includes('left')) {
-        maxWidth = floatingW - overflow.left
-        maxHeight = floatingH - (overflow.top + overflow.bottom)
-      }
-
-      // IMPORTANT – APPLY ELEMENT STYLES HERE
-      // Elements need to be resized BEFORE the `platform.getDimensions` call below
-      apply({
-        availableWidth: maxWidth - margins[1] - margins[3],
-        availableHeight: maxHeight - margins[0] - margins[2],
-        elements,
-        referenceWidth: reference.width - margins[1] - margins[3],
-      })
-
-      const nextDimensions = await platform.getDimensions(elements.floating)
-
-      const targetH = nextDimensions.height
-      const targetW = nextDimensions.width
-
-      if (floatingW !== targetW || floatingH !== targetH) {
-        return {reset: {rects: true}}
-      }
-
-      return {}
-    },
-  }
-}

package/src/core/primitives/popover/helpers.ts

@@ -1,32 +0,0 @@
-import type {ContainerWidth} from '@sanity/ui/theme'
-
-import {DEFAULT_POPOVER_PADDING} from './constants'
-
-export function calcCurrentWidth(params: {
-  mediaIndex: number
-  container: number[]
-  width: (ContainerWidth | 'fill' | null | undefined)[]
-}): number | undefined {
-  const {container, mediaIndex, width} = params
-
-  const w = width[mediaIndex]
-  const currentWidth = w === undefined ? width[width.length - 1] : w
-
-  return typeof currentWidth === 'number' ? container[currentWidth] : undefined
-}
-
-export function calcMaxWidth(params: {
-  boundaryWidth: number | undefined
-  currentWidth: number | undefined
-}): number | undefined {
-  const {boundaryWidth, currentWidth} = params
-
-  if (currentWidth === undefined && boundaryWidth === undefined) {
-    return undefined
-  }
-
-  return Math.min(
-    currentWidth ?? Infinity,
-    (boundaryWidth || Infinity) - DEFAULT_POPOVER_PADDING * 2,
-  )
-}