Skip to content

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

TypeScript
8.3 KB
Raw Blame
'use client'

import { useEffect, useId, useRef, useState } from 'react'
import { createPortal } from 'react-dom'
import { IconCopy } from '@components/Sidebar/icons'
import { useToast } from '@components/Toast'
import { IconX } from '@components/icons'
import { Button } from '@components/ui'
import { gfsFetchFileBlob } from '@lib/api'
import { assertGfsImagePreviewSize } from '@lib/gfsImagePreview'
import type { GfsImagePreviewProps } from './types'

export function GfsImagePreview({
  byteLength,
  fileName,
  mimeType,
  onClose,
  rid,
  unavailable = false,
}: GfsImagePreviewProps): React.JSX.Element {
  const titleId = useId()
  const dialogRef = useRef<HTMLElement | null>(null)
  const [previewUrl, setPreviewUrl] = useState<string | null>(null)
  const [sourceBlob, setSourceBlob] = useState<Blob | null>(null)
  const [previewError, setPreviewError] = useState<string | null>(null)
  const [copyState, setCopyState] = useState<'idle' | 'copied' | 'error'>('idle')
  const copyResetTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
  const mountedRef = useRef(true)
  const { showToast } = useToast()

  useEffect(() => {
    const previouslyFocused = document.activeElement
    dialogRef.current?.querySelector<HTMLButtonElement>('[data-preview-close]')?.focus()
    const handleKeyDown = (event: KeyboardEvent) => {
      if (event.key === 'Escape') onClose()
    }
    window.addEventListener('keydown', handleKeyDown)
    return () => {
      window.removeEventListener('keydown', handleKeyDown)
      if (previouslyFocused instanceof HTMLElement && document.contains(previouslyFocused)) {
        previouslyFocused.focus()
      }
    }
  }, [onClose])

  useEffect(() => {
    let active = true
    let objectUrl: string | null = null

    if (unavailable) {
      setPreviewUrl(null)
      setSourceBlob(null)
      setPreviewError(null)
      setCopyState('idle')
      return () => {
        active = false
      }
    }

    async function loadPreview(): Promise<void> {
      try {
        assertGfsImagePreviewSize(byteLength)
        const fetched = await gfsFetchFileBlob(rid)
        assertGfsImagePreviewSize(fetched.size)
        if (!active) return
        const blob = new Blob([fetched], { type: mimeType })
        setSourceBlob(blob)
        objectUrl = URL.createObjectURL(blob)
        setPreviewUrl(objectUrl)
      } catch (error) {
        if (!active) return
        const status = (error as { status?: number } | null)?.status
        setPreviewError(
          status === 403 || status === 404
            ? 'File unavailable.'
            : error instanceof Error
              ? error.message
              : 'Could not load the image preview.'
        )
      }
    }

    void loadPreview()
    return () => {
      active = false
      if (objectUrl) URL.revokeObjectURL(objectUrl)
    }
  }, [byteLength, mimeType, rid, unavailable])

  useEffect(() => {
    mountedRef.current = true
    return () => {
      mountedRef.current = false
      if (copyResetTimeoutRef.current) clearTimeout(copyResetTimeoutRef.current)
    }
  }, [])

  function markCopyState(state: 'copied' | 'error'): boolean {
    if (!mountedRef.current) return false
    setCopyState(state)
    if (copyResetTimeoutRef.current) clearTimeout(copyResetTimeoutRef.current)
    copyResetTimeoutRef.current = setTimeout(() => {
      if (mountedRef.current) setCopyState('idle')
    }, 2000)
    return true
  }

  async function copyImageToClipboard(): Promise<void> {
    if (!sourceBlob || !mountedRef.current) return
    try {
      if (typeof ClipboardItem !== 'undefined' && navigator.clipboard?.write) {
        let clipboardBlob: Blob | null = sourceBlob
        if (!sourceBlob.type.includes('png')) {
          clipboardBlob = await convertBlobToPng(sourceBlob)
        }
        if (!mountedRef.current) return
        if (clipboardBlob) {
          await navigator.clipboard.write([new ClipboardItem({ 'image/png': clipboardBlob })])
          if (!mountedRef.current) return
          if (markCopyState('copied')) {
            showToast(`Copied ${fileName} to the clipboard.`, { tone: 'success' })
          }
          return
        }
      }
      if (navigator.clipboard?.writeText) {
        const dataUrl = await blobToDataUrl(sourceBlob)
        if (!mountedRef.current) return
        await navigator.clipboard.writeText(dataUrl)
        if (!mountedRef.current) return
        if (markCopyState('copied')) {
          showToast(`Copied ${fileName} to the clipboard.`, { tone: 'success' })
        }
      } else {
        if (markCopyState('error')) {
          showToast('Copy failed — check browser clipboard permissions.', { tone: 'error' })
        }
      }
    } catch {
      if (markCopyState('error')) {
        showToast('Copy failed — check browser clipboard permissions.', { tone: 'error' })
      }
    }
  }

  return createPortal(
    <div
      className="cu-modal-backdrop cu-gfs-image-preview-modal"
      role="presentation"
      onMouseDown={event => {
        if (event.target === event.currentTarget) onClose()
      }}
    >
      <section
        className="cu-gfs-image-preview-dialog"
        ref={dialogRef}
        role="dialog"
        aria-modal="true"
        aria-labelledby={titleId}
      >
        <header className="cu-gfs-image-preview-dialog__header">
          <h3 id={titleId}>{unavailable ? 'File unavailable' : fileName}</h3>
          <div className="cu-gfs-image-preview-dialog__header-actions">
            <Button
              className="cu-gfs-image-preview-dialog__copy"
              variant="ghost"
              aria-label={
                copyState === 'copied' ? 'Copied image to clipboard' : 'Copy image to clipboard'
              }
              disabled={!sourceBlob || unavailable}
              onClick={() => void copyImageToClipboard()}
            >
              <IconCopy width={18} height={18} />
              <span className="cu-gfs-preview-button__label">
                {copyState === 'copied' ? 'Copied' : 'Copy'}
              </span>
            </Button>
            <Button
              className="cu-gfs-image-preview-dialog__close"
              data-preview-close
              variant="ghost"
              aria-label="Close image preview"
              onClick={onClose}
            >
              <IconX width={18} height={18} />
            </Button>
          </div>
        </header>
        <div className="cu-gfs-image-preview-dialog__body">
          {unavailable ? (
            <div className="cu-gfs-image-preview-dialog__loading" role="status">
              File unavailable.
            </div>
          ) : previewError ? (
            <div className="cu-banner cu-banner--error" role="alert">
              {previewError}
            </div>
          ) : null}
          {!unavailable && !previewError && !previewUrl ? (
            <div className="cu-gfs-image-preview-dialog__loading" role="status">
              Loading image preview…
            </div>
          ) : null}
          {!unavailable && previewUrl && !previewError ? (
            <img
              alt={`Preview of ${fileName}`}
              className="cu-gfs-image-preview-dialog__image"
              onError={() => setPreviewError('This image could not be displayed')}
              src={previewUrl}
            />
          ) : null}
        </div>
      </section>
    </div>,
    document.body
  )
}

async function convertBlobToPng(blob: Blob): Promise<Blob | null> {
  if (typeof createImageBitmap === 'undefined') return null
  try {
    const bitmap = await createImageBitmap(blob)
    const canvas = document.createElement('canvas')
    canvas.width = bitmap.width
    canvas.height = bitmap.height
    const ctx = canvas.getContext('2d')
    if (!ctx) return null
    ctx.drawImage(bitmap, 0, 0)
    return await new Promise<Blob | null>(resolve => canvas.toBlob(resolve, 'image/png'))
  } catch {
    return null
  }
}

async function blobToDataUrl(blob: Blob): Promise<string> {
  const result = await new Promise<string | ArrayBuffer | null>((resolve, reject) => {
    const reader = new FileReader()
    reader.onload = () => resolve(reader.result)
    reader.onerror = () => reject(reader.error ?? new Error('Could not read the image'))
    reader.readAsDataURL(blob)
  })
  if (typeof result !== 'string') throw new Error('Could not read the image')
  return result
}

export type { GfsImagePreviewProps } from './types'