Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
15.1 KB
Raw Blame
import { Fragment, useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react'
import type { KeyboardEvent as ReactKeyboardEvent, ReactNode } from 'react'
import { createPortal } from 'react-dom'
import { IconButton, MenuItem } from '@components/Common'
import {
  IconChevronRight,
  IconConnectors,
  IconContexts,
  IconCopy,
  IconDownload,
  IconEdit,
  IconEye,
  IconMoreVertical,
  IconPlus,
  IconShare,
  IconTrash,
  IconUpload,
} from '@components/SidebarNav/icons'
import type { GfsResourceMenuProps } from './types'

type GfsResourceMenuAction = {
  color?: 'neutral' | 'danger'
  icon: ReactNode
  key: string
  label: string
  onClick: () => void
  submenu?: boolean
}

function menuAction(
  key: string,
  label: string,
  icon: ReactNode,
  onClick: (() => void) | undefined,
  options: Pick<GfsResourceMenuAction, 'color' | 'submenu'> = {}
): GfsResourceMenuAction | null {
  return onClick ? { ...options, icon, key, label, onClick } : null
}

function isMenuAction(action: GfsResourceMenuAction | null): action is GfsResourceMenuAction {
  return action !== null
}

function horizontalBounds(anchor: HTMLElement, edgeInset: number) {
  const viewportLeft = edgeInset
  const viewportRight = window.innerWidth - edgeInset
  const drive = anchor.closest<HTMLElement>('.da-gfs-drive')
  const driveRect = drive?.getBoundingClientRect()

  // Breadcrumb menus live beside a persistent sidebar. Keep their portal
  // inside the Files surface instead of allowing right-edge alignment to push
  // the panel underneath that sidebar. Isolated consumers and zero-layout test
  // environments fall back to the viewport.
  if (!driveRect || driveRect.width <= 0) {
    return { left: viewportLeft, right: viewportRight }
  }

  return {
    left: Math.max(viewportLeft, driveRect.left),
    right: Math.min(viewportRight, driveRect.right),
  }
}

export function GfsResourceMenu({
  resourceName,
  onManage,
  onCopyLink,
  onCreateFolder,
  onDelete,
  onOpen,
  onOpenGfsLink,
  onOpenChange,
  onPreview,
  onDownload,
  onDownloadZip,
  onRename,
  onMove,
  onReplace,
}: GfsResourceMenuProps) {
  const [open, setOpen] = useState(false)
  const [shareOpen, setShareOpen] = useState(false)
  const menuRef = useRef<HTMLSpanElement | null>(null)
  const panelRef = useRef<HTMLDivElement | null>(null)
  const submenuRef = useRef<HTMLDivElement | null>(null)
  const shareTriggerRef = useRef<HTMLButtonElement | null>(null)
  const triggerRef = useRef<HTMLButtonElement | null>(null)
  const replaceInputRef = useRef<HTMLInputElement | null>(null)
  const [panelPosition, setPanelPosition] = useState<{ left: number; top: number } | null>(null)
  const [submenuPosition, setSubmenuPosition] = useState<{ left: number; top: number } | null>(null)
  const closeMenu = useCallback(() => {
    setOpen(false)
    setShareOpen(false)
  }, [])
  const onOpenChangeRef = useRef(onOpenChange)
  const prevOpenRef = useRef(false)

  useEffect(() => {
    onOpenChangeRef.current = onOpenChange
  }, [onOpenChange])

  useEffect(() => {
    if (prevOpenRef.current === open) return
    prevOpenRef.current = open
    onOpenChangeRef.current?.(open)
  }, [open])

  useEffect(
    () => () => {
      if (prevOpenRef.current) onOpenChangeRef.current?.(false)
    },
    []
  )

  useEffect(() => {
    if (!open) return
    const handlePointerDown = (event: MouseEvent) => {
      const target = event.target as Node
      if (
        menuRef.current?.contains(target) ||
        panelRef.current?.contains(target) ||
        submenuRef.current?.contains(target)
      )
        return
      closeMenu()
    }
    document.addEventListener('mousedown', handlePointerDown)
    return () => document.removeEventListener('mousedown', handlePointerDown)
  }, [closeMenu, open])

  const positionPanel = useCallback(() => {
    const trigger = triggerRef.current
    const panel = panelRef.current
    if (!trigger || !panel) return

    const triggerRect = trigger.getBoundingClientRect()
    const panelRect = panel.getBoundingClientRect()
    const edgeInset = 8
    const gap = 6
    const viewportHeight = window.innerHeight
    const bounds = horizontalBounds(trigger, edgeInset)
    const maxLeft = Math.max(bounds.left, bounds.right - panelRect.width)
    const left = Math.min(Math.max(bounds.left, triggerRect.right - panelRect.width), maxLeft)
    const opensAbove =
      triggerRect.bottom + gap + panelRect.height > viewportHeight - edgeInset &&
      triggerRect.top - gap - panelRect.height >= edgeInset
    const unclampedTop = opensAbove
      ? triggerRect.top - panelRect.height - gap
      : triggerRect.bottom + gap
    const top = Math.min(
      Math.max(edgeInset, unclampedTop),
      Math.max(edgeInset, viewportHeight - panelRect.height - edgeInset)
    )

    setPanelPosition({ left, top })
  }, [])

  useLayoutEffect(() => {
    if (!open) {
      setPanelPosition(null)
      return
    }

    positionPanel()
    window.addEventListener('resize', positionPanel)
    window.addEventListener('scroll', positionPanel, true)
    const resizeObserver =
      typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(positionPanel)
    const trigger = triggerRef.current
    const drive = trigger?.closest<HTMLElement>('.da-gfs-drive')
    if (trigger) resizeObserver?.observe(trigger)
    if (drive) resizeObserver?.observe(drive)
    if (panelRef.current) resizeObserver?.observe(panelRef.current)
    return () => {
      window.removeEventListener('resize', positionPanel)
      window.removeEventListener('scroll', positionPanel, true)
      resizeObserver?.disconnect()
    }
  }, [open, positionPanel])

  const positionSubmenu = useCallback(() => {
    const trigger = shareTriggerRef.current
    const submenu = submenuRef.current
    if (!trigger || !submenu) return

    const triggerRect = trigger.getBoundingClientRect()
    const submenuRect = submenu.getBoundingClientRect()
    const edgeInset = 8
    const gap = 6
    const viewportHeight = window.innerHeight
    const bounds = horizontalBounds(triggerRef.current ?? trigger, edgeInset)
    const opensLeft = triggerRect.right + gap + submenuRect.width > bounds.right
    const preferredLeft = opensLeft
      ? triggerRect.left - submenuRect.width - gap
      : triggerRect.right + gap
    const maxLeft = Math.max(bounds.left, bounds.right - submenuRect.width)
    const left = Math.min(Math.max(bounds.left, preferredLeft), maxLeft)
    const maxTop = Math.max(edgeInset, viewportHeight - submenuRect.height - edgeInset)
    const top = Math.min(Math.max(edgeInset, triggerRect.top), maxTop)

    setSubmenuPosition({ left, top })
  }, [])

  useLayoutEffect(() => {
    if (!shareOpen) {
      setSubmenuPosition(null)
      return
    }

    positionSubmenu()
    window.addEventListener('resize', positionSubmenu)
    window.addEventListener('scroll', positionSubmenu, true)
    const resizeObserver =
      typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(positionSubmenu)
    const trigger = triggerRef.current
    const drive = trigger?.closest<HTMLElement>('.da-gfs-drive')
    if (trigger) resizeObserver?.observe(trigger)
    if (drive) resizeObserver?.observe(drive)
    if (panelRef.current) resizeObserver?.observe(panelRef.current)
    if (shareTriggerRef.current) resizeObserver?.observe(shareTriggerRef.current)
    if (submenuRef.current) resizeObserver?.observe(submenuRef.current)
    return () => {
      window.removeEventListener('resize', positionSubmenu)
      window.removeEventListener('scroll', positionSubmenu, true)
      resizeObserver?.disconnect()
    }
  }, [panelPosition, positionSubmenu, shareOpen])

  useEffect(() => {
    if (!open) return
    panelRef.current?.querySelector<HTMLButtonElement>('[role="menuitem"]:not(:disabled)')?.focus()
    const handleKeyDown = (event: KeyboardEvent) => {
      if (event.key === 'Escape') {
        if (shareOpen) {
          event.preventDefault()
          setShareOpen(false)
          shareTriggerRef.current?.focus()
        } else {
          closeMenu()
          triggerRef.current?.focus()
        }
      }
    }
    window.addEventListener('keydown', handleKeyDown)
    return () => window.removeEventListener('keydown', handleKeyDown)
  }, [closeMenu, open, shareOpen])

  useEffect(() => {
    if (!shareOpen) return
    submenuRef.current
      ?.querySelector<HTMLButtonElement>('[role="menuitem"]:not(:disabled)')
      ?.focus()
  }, [shareOpen])

  const handleMenuKeyDown = (event: ReactKeyboardEvent<HTMLElement>) => {
    if (!open) return
    if (event.key === 'ArrowRight' && event.target === shareTriggerRef.current) {
      event.preventDefault()
      setShareOpen(true)
      return
    }
    if (
      event.key === 'ArrowLeft' &&
      shareOpen &&
      submenuRef.current?.contains(document.activeElement)
    ) {
      event.preventDefault()
      setShareOpen(false)
      shareTriggerRef.current?.focus()
      return
    }
    if (!['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) return
    const items = Array.from(
      event.currentTarget.querySelectorAll<HTMLButtonElement>('[role="menuitem"]:not(:disabled)')
    )
    if (!items.length) return
    event.preventDefault()
    const activeIndex = items.findIndex(item => item === document.activeElement)
    let nextIndex = activeIndex < 0 ? 0 : activeIndex
    if (event.key === 'Home') nextIndex = 0
    if (event.key === 'End') nextIndex = items.length - 1
    if (event.key === 'ArrowDown') nextIndex = (nextIndex + 1) % items.length
    if (event.key === 'ArrowUp') nextIndex = (nextIndex - 1 + items.length) % items.length
    items[nextIndex]?.focus()
  }

  const runAction = (action: () => void) => {
    closeMenu()
    action()
  }

  const actionGroups = [
    [
      menuAction(
        'share',
        'Share',
        <IconShare />,
        onManage ? () => setShareOpen(value => !value) : undefined,
        { submenu: true }
      ),
      onManage ? null : menuAction('copy-link', 'Copy link', <IconCopy />, onCopyLink),
      menuAction('open-folder', 'Open folder', <IconContexts />, onOpen),
      menuAction('open-gfs-link', 'Open EvenDrive link', <IconConnectors />, onOpenGfsLink),
      menuAction('preview', 'Preview', <IconEye />, onPreview),
    ].filter(isMenuAction),
    [
      menuAction('new-folder', 'New folder', <IconPlus />, onCreateFolder),
      menuAction('rename', 'Rename', <IconEdit />, onRename),
      menuAction('move', 'Move to…', <IconContexts />, onMove),
    ].filter(isMenuAction),
    [
      menuAction('download', 'Download', <IconDownload />, onDownload),
      menuAction('download-zip', 'Download as zip', <IconDownload />, onDownloadZip),
      menuAction(
        'replace',
        'Replace file',
        <IconUpload />,
        onReplace ? () => replaceInputRef.current?.click() : undefined
      ),
    ].filter(isMenuAction),
    [menuAction('delete', 'Delete', <IconTrash />, onDelete, { color: 'danger' })].filter(
      isMenuAction
    ),
  ].filter(group => group.length > 0)

  return (
    <span
      className={`da-gfs-resource-menu${open ? ' is-open' : ''}`}
      ref={menuRef}
      onKeyDown={handleMenuKeyDown}
    >
      <IconButton
        className="da-gfs-resource-menu__trigger"
        label={`Options for ${resourceName}`}
        aria-haspopup="menu"
        aria-expanded={open}
        onClick={event => {
          event.stopPropagation()
          if (open) {
            closeMenu()
          } else {
            setOpen(true)
          }
        }}
        ref={triggerRef}
        size="sm"
        variant="ghost"
      >
        <IconMoreVertical />
      </IconButton>
      {open
        ? createPortal(
            <Fragment>
              <div
                className="da-gfs-resource-menu__panel"
                ref={panelRef}
                role="menu"
                aria-label={`Actions for ${resourceName}`}
                style={
                  panelPosition
                    ? { left: panelPosition.left, top: panelPosition.top }
                    : { left: 0, top: 0, visibility: 'hidden' }
                }
                onKeyDown={handleMenuKeyDown}
              >
                {actionGroups.map((group, groupIndex) => (
                  <Fragment key={`group-${groupIndex}`}>
                    {groupIndex > 0 ? (
                      <div className="da-gfs-resource-menu__separator" role="separator" />
                    ) : null}
                    {group.map(action => (
                      <MenuItem
                        aria-expanded={action.submenu ? shareOpen : undefined}
                        aria-haspopup={action.submenu ? 'menu' : undefined}
                        color={action.color}
                        data-gfs-action={action.key}
                        key={action.key}
                        leadingIcon={action.icon}
                        role="menuitem"
                        ref={action.submenu ? shareTriggerRef : undefined}
                        trailingIcon={action.submenu ? <IconChevronRight /> : undefined}
                        onMouseEnter={action.submenu ? () => setShareOpen(true) : undefined}
                        onClick={() => {
                          if (action.submenu) {
                            action.onClick()
                          } else {
                            runAction(action.onClick)
                          }
                        }}
                      >
                        {action.label}
                      </MenuItem>
                    ))}
                  </Fragment>
                ))}
              </div>
              {shareOpen && onManage ? (
                <div
                  aria-label={`Share options for ${resourceName}`}
                  className="da-gfs-resource-menu__submenu"
                  ref={submenuRef}
                  role="menu"
                  style={
                    submenuPosition
                      ? { left: submenuPosition.left, top: submenuPosition.top }
                      : { left: 0, top: 0, visibility: 'hidden' }
                  }
                  onKeyDown={handleMenuKeyDown}
                >
                  <MenuItem
                    data-gfs-action="share-access"
                    leadingIcon={<IconShare />}
                    role="menuitem"
                    onClick={() => runAction(onManage)}
                  >
                    Share
                  </MenuItem>
                  {onCopyLink ? (
                    <MenuItem
                      data-gfs-action="copy-link"
                      leadingIcon={<IconCopy />}
                      role="menuitem"
                      onClick={() => runAction(onCopyLink)}
                    >
                      Copy link
                    </MenuItem>
                  ) : null}
                </div>
              ) : null}
            </Fragment>,
            document.body
          )
        : null}
      {onReplace ? (
        <input
          aria-label={`Replace ${resourceName}`}
          className="visually-hidden"
          ref={replaceInputRef}
          type="file"
          onChange={event => {
            const file = event.currentTarget.files?.[0]
            event.currentTarget.value = ''
            if (!file) return
            closeMenu()
            onReplace(file)
          }}
        />
      ) : null}
    </span>
  )
}