@sanity/ui 3.0.0-static.8 → 3.0.0

package/src/ui/components/dialog/dialog.tsx

@@ -1,432 +0,0 @@
-import {CloseIcon} from '@sanity/icons'
-import {
-  composeClassNames,
-  ContainerStyleProps,
-  dialog,
-  dialogCardRoot,
-  dialogContainer,
-  dialogContent,
-  dialogFooter,
-  dialogHeader,
-  dialogLayout,
-  PaddingStyleProps,
-  RadiusStyleProps,
-  ResponsiveProp,
-  ShadowStyleProps,
-} from '@sanity/ui/css'
-import {ThemeColorSchemeKey} from '@sanity/ui/theme'
-import {
-  FocusEvent,
-  ForwardedRef,
-  forwardRef,
-  ReactNode,
-  useCallback,
-  useEffect,
-  useImperativeHandle,
-  useRef,
-} from 'react'
-
-import {Z_OFFSETS} from '../../constants'
-import {
-  containsOrEqualsElement,
-  focusFirstDescendant,
-  focusLastDescendant,
-  isHTMLElement,
-} from '../../helpers'
-import {
-  useArrayProp,
-  useClickOutsideEvent,
-  useGlobalKeyDown,
-  usePrefersReducedMotion,
-} from '../../hooks'
-import {Box, Button, Card, Container, Flex, Text} from '../../primitives'
-import {CardTone, DialogPosition, Props, Radius} from '../../types'
-import {Layer, LayerProps, Portal, useBoundaryElement, useLayer, usePortal} from '../../utils'
-import {useDialog} from './useDialog'
-
-/**
- * @public
- */
-export interface DialogProps extends ContainerStyleProps, PaddingStyleProps, ShadowStyleProps {
-  /**
-   * @beta
-   */
-  __unstable_autoFocus?: boolean
-  /**
-   * @beta
-   */
-  __unstable_hideCloseButton?: boolean
-  /**
-   * Whether the dialog should animate in on mount.
-   *
-   * @beta
-   * @defaultValue false
-   */
-  animate?: boolean
-  cardRadius?: ResponsiveProp<Radius>
-  contentRef?: ForwardedRef<HTMLDivElement>
-  footer?: ReactNode
-  header?: ReactNode
-  id: string
-  /** A callback that fires when the dialog becomes the top layer when it was not the top layer before. */
-  onActivate?: LayerProps['onActivate']
-  onClickOutside?: () => void
-  onClose?: () => void
-  open?: boolean
-  portal?: string
-  position?: DialogPosition | DialogPosition[]
-  scheme?: ThemeColorSchemeKey
-  tone?: CardTone
-  zOffset?: number | number[]
-}
-
-interface DialogCardProps extends ContainerStyleProps, RadiusStyleProps, ShadowStyleProps {
-  /**
-   * @beta
-   */
-  __unstable_autoFocus: boolean
-  /**
-   * @beta
-   */
-  __unstable_hideCloseButton: boolean
-  children: ReactNode
-  contentRef?: ForwardedRef<HTMLDivElement>
-  footer: ReactNode
-  header: ReactNode
-  id: string
-  onClickOutside?: () => void
-  onClose?: () => void
-  portal?: string
-  // radius: Radius | Radius[]
-  scheme?: ThemeColorSchemeKey
-  // shadow: number | number[]
-  tone?: CardTone
-}
-
-function isTargetWithinScope(
-  boundaryElement: HTMLElement | null,
-  portalElement: HTMLElement | null,
-  target: Node,
-): boolean {
-  if (!boundaryElement || !portalElement) return true
-
-  return (
-    containsOrEqualsElement(boundaryElement, target) ||
-    containsOrEqualsElement(portalElement, target)
-  )
-}
-
-const DialogCard = forwardRef(function DialogCard(
-  props: DialogCardProps,
-  forwardedRef: ForwardedRef<HTMLDivElement>,
-) {
-  const {
-    __unstable_autoFocus: autoFocus,
-    __unstable_hideCloseButton: hideCloseButton,
-    children,
-    contentRef: forwardedContentRef,
-    footer,
-    header,
-    id,
-    onClickOutside,
-    onClose,
-    portal: portalProp,
-    radius: radiusProp,
-    scheme,
-    shadow: shadowProp = 4,
-    tone,
-    width: widthProp,
-  } = props
-  const portal = usePortal()
-  const portalElement = portalProp ? portal.elements?.[portalProp] || null : portal.element
-  const boundaryElement = useBoundaryElement().element
-  const radius = useArrayProp(radiusProp)
-  const shadow = useArrayProp(shadowProp)
-  const width = useArrayProp(widthProp)
-  const ref = useRef<HTMLDivElement | null>(null)
-  const contentRef = useRef<HTMLDivElement | null>(null)
-  const layer = useLayer()
-  const {isTopLayer} = layer
-  const labelId = `${id}_label`
-  const showCloseButton = Boolean(onClose) && hideCloseButton === false
-  const showHeader = Boolean(header) || showCloseButton
-
-  useImperativeHandle<HTMLDivElement | null, HTMLDivElement | null>(forwardedRef, () => ref.current)
-  useImperativeHandle<HTMLDivElement | null, HTMLDivElement | null>(
-    forwardedContentRef,
-    () => contentRef.current,
-  )
-
-  useEffect(() => {
-    if (!autoFocus) return
-
-    // On mount: focus the first focusable element
-    if (ref.current) {
-      focusFirstDescendant(ref.current)
-    }
-  }, [autoFocus, ref])
-
-  useGlobalKeyDown(
-    useCallback(
-      (event: KeyboardEvent) => {
-        if (!isTopLayer || !onClose) return
-
-        const target = document.activeElement
-
-        if (target && !isTargetWithinScope(boundaryElement, portalElement, target)) {
-          // Ignore key presses when the focused element is outside of scope
-          return
-        }
-
-        if (event.key === 'Escape') {
-          event.preventDefault()
-          event.stopPropagation()
-          onClose()
-        }
-      },
-      [boundaryElement, isTopLayer, onClose, portalElement],
-    ),
-  )
-
-  useClickOutsideEvent(
-    isTopLayer &&
-      onClickOutside &&
-      ((event) => {
-        const target = event.target as Node | null
-
-        if (target && !isTargetWithinScope(boundaryElement, portalElement, target)) {
-          // Ignore clicks outside of the scope
-          return
-        }
-
-        onClickOutside()
-      }),
-    () => [ref.current],
-  )
-
-  return (
-    <Container
-      align="center"
-      className={dialogContainer()}
-      data-ui="DialogCard"
-      direction="column"
-      display="flex"
-      justify="center"
-      width={width}
-    >
-      <Card
-        className={dialogCardRoot()}
-        display="flex"
-        radius={radius}
-        ref={ref}
-        scheme={scheme}
-        shadow={shadow}
-        tone={tone}
-      >
-        <Flex className={dialogLayout()} direction="column" flex={1}>
-          {showHeader && (
-            <Box className={dialogHeader()} position="relative">
-              <Flex align="flex-start" padding={3}>
-                <Box flex={1} padding={2}>
-                  {header && (
-                    <Text id={labelId} size={1} weight="semibold">
-                      {header}
-                    </Text>
-                  )}
-                </Box>
-                {showCloseButton && (
-                  <Box flex="none">
-                    <Button
-                      aria-label="Close dialog"
-                      disabled={!onClose}
-                      icon={CloseIcon}
-                      mode="bleed"
-                      onClick={onClose}
-                      padding={2}
-                    />
-                  </Box>
-                )}
-              </Flex>
-            </Box>
-          )}
-          <Box
-            className={dialogContent()}
-            flex={1}
-            overflow="auto"
-            position="relative"
-            ref={contentRef}
-            tabIndex={-1}
-          >
-            {children}
-          </Box>
-          {footer && (
-            <Box className={dialogFooter()} position="relative">
-              {footer}
-            </Box>
-          )}
-        </Flex>
-      </Card>
-    </Container>
-  )
-})
-
-DialogCard.displayName = 'ForwardRef(DialogCard)'
-
-/**
- * The Dialog component.
- *
- * @public
- */
-export const Dialog = forwardRef(function Dialog(
-  props: Props<DialogProps, 'div'>,
-  ref: ForwardedRef<HTMLDivElement>,
-) {
-  const context = useDialog()
-  const {
-    __unstable_autoFocus: autoFocus = true,
-    __unstable_hideCloseButton: hideCloseButton = false,
-    animate: _animate = false,
-    cardRadius: cardRadiusProp = 4,
-    // cardShadow = 3,
-    children,
-    className,
-    contentRef,
-    footer,
-    header,
-    id,
-    onActivate,
-    onClickOutside,
-    onClose,
-    onFocus,
-    padding = 3,
-    portal: portalProp,
-    position: _positionProp,
-    scheme,
-    shadow: cardShadow,
-    width: widthProp = 0,
-    zOffset: _zOffsetProp,
-    tone,
-    ...restProps
-  } = props
-  const positionProp = _positionProp ?? context.position ?? 'fixed'
-  const zOffsetProp = _zOffsetProp ?? context.zOffset ?? Z_OFFSETS.dialog
-  const prefersReducedMotion = usePrefersReducedMotion()
-  const animate = prefersReducedMotion ? false : _animate
-  const portal = usePortal()
-  const portalElement = portalProp ? portal.elements?.[portalProp] || null : portal.element
-  const boundaryElement = useBoundaryElement().element
-  const cardRadius = useArrayProp(cardRadiusProp)
-  const position = useArrayProp(positionProp)
-  const width = useArrayProp(widthProp)
-  const zOffset = useArrayProp(zOffsetProp)
-  const preDivRef = useRef<HTMLDivElement | null>(null)
-  const postDivRef = useRef<HTMLDivElement | null>(null)
-  const cardRef = useRef<HTMLDivElement | null>(null)
-  const focusedElementRef = useRef<HTMLElement | null>(null)
-
-  const handleFocus = useCallback(
-    (event: FocusEvent<HTMLDivElement>) => {
-      onFocus?.(event)
-
-      const target = event.target
-      const cardElement = cardRef.current
-
-      if (cardElement && target === preDivRef.current) {
-        focusLastDescendant(cardElement)
-
-        return
-      }
-
-      if (cardElement && target === postDivRef.current) {
-        focusFirstDescendant(cardElement)
-
-        return
-      }
-
-      if (isHTMLElement(event.target)) {
-        focusedElementRef.current = event.target
-      }
-    },
-    [onFocus],
-  )
-
-  const labelId = `${id}_label`
-
-  const rootClickTimeoutRef = useRef<NodeJS.Timeout>(undefined)
-
-  // If the resulting active element (a.k.a. focused element) is not withing scope when clicking
-  // within the dialog, then we want to focus the previously interactive element in the dialog instead.
-  // This is to allow the user to tab or close the dialog by pressing escape.
-  const handleRootClick = useCallback(() => {
-    if (rootClickTimeoutRef.current) {
-      clearTimeout(rootClickTimeoutRef.current)
-    }
-
-    rootClickTimeoutRef.current = setTimeout(() => {
-      const activeElement = document.activeElement
-
-      if (activeElement && !isTargetWithinScope(boundaryElement, portalElement, activeElement)) {
-        const target = focusedElementRef.current
-
-        if (!target || !document.body.contains(target)) {
-          // No previously focused element, or it's not in the document anymore
-          const cardElement = cardRef.current
-          if (cardElement) focusFirstDescendant(cardElement)
-
-          return
-        }
-
-        target.focus()
-      }
-    }, 0)
-  }, [boundaryElement, portalElement])
-
-  return (
-    <Portal __unstable_name={portalProp}>
-      <Layer
-        {...restProps}
-        aria-labelledby={labelId}
-        aria-modal
-        className={composeClassNames(className, dialog())}
-        data-animate={animate ? '' : undefined}
-        data-ui="Dialog"
-        display="flex"
-        id={id}
-        onActivate={onActivate}
-        onClick={handleRootClick}
-        onFocus={handleFocus}
-        padding={padding}
-        position={position}
-        ref={ref}
-        role="dialog"
-        zOffset={zOffset}
-      >
-        {/* eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex */}
-        <div ref={preDivRef} tabIndex={0} />
-        <DialogCard
-          __unstable_autoFocus={autoFocus}
-          __unstable_hideCloseButton={hideCloseButton}
-          contentRef={contentRef}
-          footer={footer}
-          header={header}
-          id={id}
-          onClickOutside={onClickOutside}
-          onClose={onClose}
-          portal={portalProp}
-          radius={cardRadius}
-          ref={cardRef}
-          scheme={scheme}
-          shadow={cardShadow}
-          tone={tone}
-          width={width}
-        >
-          {children}
-        </DialogCard>
-        {/* eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex */}
-        <div ref={postDivRef} tabIndex={0} />
-      </Layer>
-    </Portal>
-  )
-})
-
-Dialog.displayName = 'ForwardRef(Dialog)'

package/src/ui/components/dialog/dialogProvider.tsx

@@ -1,35 +0,0 @@
-import {ReactElement, ReactNode, useMemo} from 'react'
-
-import {DialogPosition} from '../../types'
-import {DialogContext, DialogContextValue} from './dialogContext'
-
-/**
- * This API might change. DO NOT USE IN PRODUCTION.
- * @beta
- */
-export interface DialogProviderProps {
-  children?: ReactNode
-  position?: DialogPosition | DialogPosition[]
-  zOffset?: number | number[]
-}
-
-/**
- * This API might change. DO NOT USE IN PRODUCTION.
- * @beta
- */
-export function DialogProvider(props: DialogProviderProps): ReactElement {
-  const {children, position, zOffset} = props
-
-  const contextValue: DialogContextValue = useMemo(
-    () => ({
-      version: 0.0,
-      position,
-      zOffset,
-    }),
-    [position, zOffset],
-  )
-
-  return <DialogContext.Provider value={contextValue}>{children}</DialogContext.Provider>
-}
-
-DialogProvider.displayName = 'DialogProvider'

package/src/ui/components/hotkeys/hotkeys.tsx

@@ -1,54 +0,0 @@
-import {GapStyleProps, RadiusStyleProps, ResponsiveProp} from '@sanity/ui/css'
-import {FontTextSize, Space} from '@sanity/ui/theme'
-import {ForwardedRef, forwardRef} from 'react'
-
-import {Box, KBD} from '../../primitives'
-import {Props} from '../../types'
-
-/**
- * @public
- */
-export interface HotkeysProps extends GapStyleProps, RadiusStyleProps {
-  fontSize?: ResponsiveProp<FontTextSize>
-  padding?: ResponsiveProp<Space>
-  /** @deprecated Use `gap` instead. */
-  space?: ResponsiveProp<Space>
-  keys?: string[]
-}
-
-/**
- * Represent hotkeys (a keyboard combination) with semantic `<kbd>` elements.
- *
- * @public
- */
-export const Hotkeys = forwardRef(function Hotkeys(
-  props: Props<HotkeysProps, 'div'>,
-  ref: ForwardedRef<HTMLDivElement>,
-) {
-  const {fontSize, gap, gapX, gapY, keys, padding, radius, space = 0.5, ...restProps} = props
-
-  if (!keys || keys.length === 0) {
-    return undefined
-  }
-
-  return (
-    <Box
-      as="kbd"
-      data-ui="Hotkeys"
-      {...restProps}
-      display="flex"
-      gap={gap ?? space}
-      gapX={gapX}
-      gapY={gapY}
-      ref={ref}
-    >
-      {keys.map((key, i) => (
-        <KBD fontSize={fontSize} key={i} padding={padding} radius={radius}>
-          {key}
-        </KBD>
-      ))}
-    </Box>
-  )
-})
-
-Hotkeys.displayName = 'ForwardRef(Hotkeys)'

package/src/ui/components/menu/__workshop__/menuButton.tsx

@@ -1,80 +0,0 @@
-import {ClockIcon, CommentIcon, ExpandIcon, SearchIcon} from '@sanity/icons'
-import {
-  Box,
-  Button,
-  Card,
-  Grid,
-  LayerProvider,
-  Menu,
-  MenuButton,
-  MenuButtonProps,
-  MenuDivider,
-  MenuItem,
-} from '@sanity/ui'
-import {useAction, useBoolean, useSelect} from '@sanity/ui-workshop'
-import {useMemo} from 'react'
-
-import {WORKSHOP_CARD_TONE_OPTIONS} from '../../../../../workshop/constants'
-
-export default function MenuButtonStory() {
-  const layoutTone = useSelect('Layout tone', WORKSHOP_CARD_TONE_OPTIONS, 'default', 'Props')
-  const portal = useBoolean('Portal', false, 'Props')
-
-  const popover: MenuButtonProps['popover'] = useMemo(
-    () => ({
-      constrainSize: true,
-      portal,
-    }),
-    [portal],
-  )
-
-  return (
-    <Card height="fill" tone={layoutTone}>
-      <Box padding={[4, 5, 6]}>
-        <Grid columns={3} gap={2}>
-          <Button id="prev-button" mode="ghost" text="Prev" />
-          <LayerProvider>
-            <MenuButton
-              button={<Button text="Open" />}
-              id="menu-button"
-              menu={
-                <Menu>
-                  <MenuItem
-                    icon={SearchIcon}
-                    id="menu-item-1"
-                    onClick={useAction('Search')}
-                    text="Search"
-                  />
-                  <MenuItem
-                    icon={ClockIcon}
-                    id="menu-item-2"
-                    onClick={useAction('Clock')}
-                    text="Clock"
-                  />
-                  <MenuItem
-                    disabled
-                    icon={CommentIcon}
-                    id="menu-item-3"
-                    onClick={useAction('Comment')}
-                    text="Comment"
-                  />
-                  <MenuDivider />
-                  <MenuItem
-                    icon={ExpandIcon}
-                    id="menu-item-4"
-                    onClick={useAction('Expand')}
-                    text="Expand"
-                  />
-                </Menu>
-              }
-              onClose={useAction('onClose')}
-              onOpen={useAction('onOpen')}
-              popover={popover}
-            />
-          </LayerProvider>
-          <Button mode="ghost" id="next-button" text="Next" />
-        </Grid>
-      </Box>
-    </Card>
-  )
-}

package/src/ui/components/menu/__workshop__/tones.tsx

@@ -1,25 +0,0 @@
-import {CubeIcon} from '@sanity/icons'
-import {Box, Card, LayerProvider, Menu, MenuItem} from '@sanity/ui'
-import {THEME_COLOR_STATE_TONES} from '@sanity/ui/theme'
-import {useBoolean, useSelect} from '@sanity/ui-workshop'
-
-import {WORKSHOP_CARD_TONE_OPTIONS} from '../../../../../workshop/constants'
-
-export default function TonesStory() {
-  const disabled = useBoolean('Disabled', false, 'Props')
-  const parentTone = useSelect('Parent tone', WORKSHOP_CARD_TONE_OPTIONS, 'default', 'Props')
-
-  return (
-    <LayerProvider>
-      <Box padding={[4, 5, 6]}>
-        <Card radius={3} shadow={3} tone={parentTone}>
-          <Menu>
-            {THEME_COLOR_STATE_TONES.map((tone) => (
-              <MenuItem disabled={disabled} icon={CubeIcon} key={tone} text={tone} tone={tone} />
-            ))}
-          </Menu>
-        </Card>
-      </Box>
-    </LayerProvider>
-  )
-}