Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

11.9 KB
Raw Blame
import { useActions, useValues } from 'kea'
import { useCallback, useEffect, useRef, useState } from 'react'

import { IconChevronLeft, IconChevronRight, IconX } from '@posthog/icons'
import {
    LemonButton,
    LemonDivider,
    LemonFileInput,
    LemonModal,
    LemonSkeleton,
    lemonToast,
    Spinner,
} from '@posthog/lemon-ui'

import { ZoomableImage } from 'lib/components/ZoomableImage/ZoomableImage'
import { useUploadFiles } from 'lib/hooks/useUploadFiles'
import { backendAssetUrl } from 'lib/utils/apiHost'

import { experimentLogic } from '../experimentLogic'
import { VariantTag } from './VariantTag'

export function VariantScreenshot({
    variantKey,
    rolloutPercentage,
}: {
    variantKey: string
    rolloutPercentage: number
}): JSX.Element {
    const { experiment } = useValues(experimentLogic)
    const { updateExperimentVariantImages, reportExperimentVariantScreenshotUploaded } = useActions(experimentLogic)

    const getInitialMediaIds = (): string[] => {
        const variantImages = experiment.parameters?.variant_screenshot_media_ids?.[variantKey]
        if (!variantImages) {
            return []
        }

        return Array.isArray(variantImages) ? variantImages : [variantImages]
    }

    const [mediaIds, setMediaIds] = useState<string[]>(getInitialMediaIds)
    const [loadingImages, setLoadingImages] = useState<Record<string, boolean>>({})
    const [selectedImageIndex, setSelectedImageIndex] = useState<number | null>(null)

    const [isFocused, setIsFocused] = useState(false)
    const containerRef = useRef<HTMLDivElement>(null)

    const { setFilesToUpload, filesToUpload, uploading } = useUploadFiles({
        onUpload: (_, __, id) => {
            if (!id) {
                return
            }
            if (mediaIds.length >= 5) {
                lemonToast.error('Maximum of 5 images allowed')
                return
            }

            setMediaIds((prev) => {
                const newMediaIds = [...prev, id]
                const updatedVariantImages = {
                    ...experiment.parameters?.variant_screenshot_media_ids,
                    [variantKey]: newMediaIds,
                }

                updateExperimentVariantImages(updatedVariantImages)
                reportExperimentVariantScreenshotUploaded(experiment.id)
                return newMediaIds
            })
        },
        onError: (detail) => {
            lemonToast.error(`Error uploading image: ${detail}`)
        },
    })

    const handlePaste = useCallback(
        (e: React.ClipboardEvent): void => {
            if (uploading) {
                return
            }

            const items = e.clipboardData?.items
            if (!items) {
                return
            }

            for (let i = 0; i < items.length; i++) {
                const item = items[i]
                if (item.type.startsWith('image/')) {
                    e.preventDefault()
                    const file = item.getAsFile()
                    if (file) {
                        if (mediaIds.length >= 5) {
                            lemonToast.error('Maximum of 5 images allowed')
                            return
                        }
                        setFilesToUpload([file])
                    } else {
                        lemonToast.error('Could not read image from clipboard')
                    }
                    return
                }
            }
        },
        [mediaIds.length, setFilesToUpload, uploading]
    )

    const handleImageLoad = (mediaId: string): void => {
        setLoadingImages((prev) => ({ ...prev, [mediaId]: false }))
    }

    const handleImageError = (mediaId: string): void => {
        setLoadingImages((prev) => ({ ...prev, [mediaId]: false }))
    }

    const handleDelete = (indexToDelete: number): void => {
        const newMediaIds = mediaIds.filter((_, index) => index !== indexToDelete)
        setMediaIds(newMediaIds)

        const updatedVariantImages = {
            ...experiment.parameters?.variant_screenshot_media_ids,
            [variantKey]: newMediaIds,
        }

        updateExperimentVariantImages(updatedVariantImages)
    }

    const getThumbnailWidth = (): string => {
        const totalItems = mediaIds.length < 5 ? mediaIds.length + 1 : mediaIds.length
        switch (totalItems) {
            case 1:
                return 'w-20'
            case 2:
                return 'w-20'
            case 3:
                return 'w-16'
            case 4:
                return 'w-14'
            case 5:
                return 'w-12'
            default:
                return 'w-20'
        }
    }

    const widthClass = getThumbnailWidth()

    const getMediaSrc = (mediaId: string): string =>
        mediaId.startsWith('data:') ? mediaId : backendAssetUrl(`/uploaded_media/${mediaId}`)

    const showPrevious = (): void =>
        setSelectedImageIndex((prev) => (prev === null ? prev : (prev - 1 + mediaIds.length) % mediaIds.length))
    const showNext = (): void => setSelectedImageIndex((prev) => (prev === null ? prev : (prev + 1) % mediaIds.length))

    // Arrow-key navigation while the screenshot viewer is open.
    useEffect(() => {
        if (selectedImageIndex === null || mediaIds.length <= 1) {
            return
        }
        const onKeyDown = (e: KeyboardEvent): void => {
            if (e.key === 'ArrowLeft') {
                showPrevious()
            } else if (e.key === 'ArrowRight') {
                showNext()
            }
        }
        window.addEventListener('keydown', onKeyDown)
        return () => window.removeEventListener('keydown', onKeyDown)
        // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [selectedImageIndex, mediaIds.length])

    return (
        <div
            ref={containerRef}
            className={`deprecated-space-y-4 rounded p-1 -m-1 outline-none transition-colors ${
                isFocused ? 'ring-1 ring-accent' : ''
            }`}
            tabIndex={0}
            onPaste={handlePaste}
            onFocus={() => setIsFocused(true)}
            onBlur={(e) => {
                if (!containerRef.current?.contains(e.relatedTarget as Node)) {
                    setIsFocused(false)
                }
            }}
        >
            <div className="flex gap-4 items-start">
                {mediaIds.map((mediaId, index) => (
                    <div key={mediaId} className="relative">
                        <div className="text-secondary inline-flex flow-row items-center gap-1 cursor-pointer">
                            <div onClick={() => setSelectedImageIndex(index)} className="cursor-zoom-in relative">
                                <div
                                    className={`relative flex overflow-hidden select-none ${widthClass} h-16 rounded before:absolute before:inset-0 before:border before:rounded`}
                                >
                                    {loadingImages[mediaId] && <LemonSkeleton className="absolute inset-0" />}
                                    <img
                                        className="w-full h-full object-cover"
                                        src={getMediaSrc(mediaId)}
                                        alt={`Variant screenshot thumbnail ${index + 1}`}
                                        onError={() => handleImageError(mediaId)}
                                        onLoad={() => handleImageLoad(mediaId)}
                                    />
                                </div>
                                <div className="absolute -inset-2 group">
                                    <LemonButton
                                        icon={<IconX />}
                                        onClick={(e) => {
                                            e.stopPropagation()
                                            handleDelete(index)
                                        }}
                                        size="small"
                                        tooltip="Remove"
                                        tooltipPlacement="right"
                                        noPadding
                                        className="group-hover:flex hidden absolute right-0 top-0"
                                    />
                                </div>
                            </div>
                        </div>
                    </div>
                ))}

                {mediaIds.length < 5 && (
                    <div className={`relative ${widthClass} h-16`}>
                        <LemonFileInput
                            accept="image/*"
                            multiple={false}
                            onChange={setFilesToUpload}
                            loading={uploading}
                            value={filesToUpload}
                            showUploadedFiles={false}
                            callToAction={
                                <div className="flex items-center justify-center w-full h-16 border border-dashed rounded cursor-pointer hover:border-accent">
                                    {uploading ? (
                                        <Spinner className="text-secondary" />
                                    ) : (
                                        <span className="text-2xl text-secondary">+</span>
                                    )}
                                </div>
                            }
                        />
                    </div>
                )}
                {isFocused && mediaIds.length < 5 && (
                    <div className="flex items-center h-16">
                        <span className="text-xs text-secondary whitespace-nowrap">⌘V to paste</span>
                    </div>
                )}
            </div>

            <LemonModal
                isOpen={selectedImageIndex !== null}
                onClose={() => setSelectedImageIndex(null)}
                width="90vw"
                maxWidth={1400}
                title={
                    <div className="flex items-center gap-2">
                        <span>
                            Screenshot {selectedImageIndex !== null ? selectedImageIndex + 1 : ''} of {mediaIds.length}
                        </span>
                        <LemonDivider className="my-0 mx-1" vertical />
                        <VariantTag variantKey={variantKey} />
                        {rolloutPercentage !== undefined && (
                            <span className="text-secondary text-sm">({rolloutPercentage}% rollout)</span>
                        )}
                    </div>
                }
            >
                {selectedImageIndex !== null && mediaIds[selectedImageIndex] && (
                    <div className="flex items-center gap-2">
                        {mediaIds.length > 1 && (
                            <LemonButton
                                icon={<IconChevronLeft />}
                                onClick={showPrevious}
                                size="large"
                                tooltip="Previous screenshot"
                                aria-label="Previous screenshot"
                            />
                        )}
                        <ZoomableImage
                            src={getMediaSrc(mediaIds[selectedImageIndex])}
                            alt={`Screenshot ${selectedImageIndex + 1}: ${variantKey}`}
                            resetKey={selectedImageIndex}
                            className="flex-1 h-[80vh]"
                        />
                        {mediaIds.length > 1 && (
                            <LemonButton
                                icon={<IconChevronRight />}
                                onClick={showNext}
                                size="large"
                                tooltip="Next screenshot"
                                aria-label="Next screenshot"
                            />
                        )}
                    </div>
                )}
            </LemonModal>
        </div>
    )
}