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.

9.2 KB
Raw Blame
import './DefinitionPopover.scss'

import clsx from 'clsx'
import { useActions, useValues } from 'kea'

import { IconPin, IconPinFilled } from '@posthog/icons'
import { LemonButton, LemonDivider, ProfilePicture } from '@posthog/lemon-ui'

import { DefinitionPopoverCard } from 'lib/components/DefinitionPopover/DefinitionPopoverCard'
import { DefinitionPopoverGrid } from 'lib/components/DefinitionPopover/DefinitionPopoverGrid'
import { DefinitionPopoverState, definitionPopoverLogic } from 'lib/components/DefinitionPopover/definitionPopoverLogic'
import { ImageCarousel } from 'lib/components/ImageCarousel/ImageCarousel'
import { taxonomicFilterLogic } from 'lib/components/TaxonomicFilter/taxonomicFilterLogic'
import { taxonomicFilterPinnedPropertiesLogic } from 'lib/components/TaxonomicFilter/taxonomicFilterPinnedPropertiesLogic'
import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
import { dayjs } from 'lib/dayjs'
import { LemonMarkdown } from 'lib/lemon-ui/LemonMarkdown'
import { Link } from 'lib/lemon-ui/Link'
import { eventUsageLogic } from 'lib/utils/eventUsageLogic'

import { getCoreFilterDefinition } from '~/taxonomy/helpers'
import { CoreFilterDefinition, UserBasicType } from '~/types'

interface DefinitionPopoverProps {
    children: React.ReactNode
}

// Wrapper
function Wrapper({ children }: DefinitionPopoverProps): JSX.Element {
    const { state } = useValues(definitionPopoverLogic)
    return <div className={clsx('definition-popover', state)}>{children}</div>
}

interface HeaderProps {
    title: React.ReactNode
    headerTitle: React.ReactNode
    editHeaderTitle: React.ReactNode
    icon: React.ReactNode
    onEdit?: () => void
    onView?: () => void
}

function Header({
    title,
    headerTitle,
    editHeaderTitle,
    icon,
    onEdit: _onEdit,
    onView: _onView,
}: HeaderProps): JSX.Element {
    const { state, type, definition, viewFullDetailUrl, hideView, hideEdit, isViewable, openDetailInNewTab } =
        useValues(definitionPopoverLogic)
    const { setPopoverState } = useActions(definitionPopoverLogic)
    const { reportDataManagementDefinitionClickView, reportDataManagementDefinitionClickEdit } =
        useActions(eventUsageLogic)
    const { taxonomicGroups } = useValues(taxonomicFilterLogic)
    const { isPinned } = useValues(taxonomicFilterPinnedPropertiesLogic)
    const { togglePin } = useActions(taxonomicFilterPinnedPropertiesLogic)

    const onEdit = (): void => {
        setPopoverState(DefinitionPopoverState.Edit)
        _onEdit?.()
        reportDataManagementDefinitionClickEdit(type)
    }
    const onView = (): void => {
        setPopoverState(DefinitionPopoverState.View)
        _onView?.()
        reportDataManagementDefinitionClickView(type)
    }

    const pinValue = definition?.name ?? null
    const groupType = type as TaxonomicFilterGroupType
    const groupName = taxonomicGroups.find((g) => g.type === groupType)?.name ?? type
    const pinned = isPinned(groupType, pinValue)

    return (
        <div className="definition-popover-header">
            <div className="definition-popover-header-actions flex items-center justify-between mb-1">
                {pinValue !== null && (
                    <LemonButton
                        size="xsmall"
                        type="secondary"
                        icon={pinned ? <IconPinFilled /> : <IconPin />}
                        onClick={() => togglePin(groupType, groupName, pinValue, definition)}
                        tooltip="Pin items to keep them available for quick access"
                        data-attr="definition-popover-pin"
                    >
                        {pinned ? 'Unpin' : 'Pin'}
                    </LemonButton>
                )}
                {state === DefinitionPopoverState.View && (
                    <div className="definition-popover-header-row-buttons flex gap-4 text-[0.8125rem] click-outside-block">
                        {!hideEdit && isViewable && <Link onClick={onEdit}>Edit</Link>}
                        {!hideView && isViewable && viewFullDetailUrl && (
                            <Link
                                target={openDetailInNewTab ? '_blank' : undefined}
                                to={viewFullDetailUrl}
                                onClick={onView}
                            >
                                View
                            </Link>
                        )}
                    </div>
                )}
            </div>
            <div className="definition-popover-header-row">
                <div className="definition-popover-header-row-title">
                    {state === DefinitionPopoverState.Edit ? editHeaderTitle : headerTitle}
                </div>
            </div>
            <div className="definition-popover-title">
                {icon}
                {title}
            </div>
        </div>
    )
}

function Description({ description }: { description: React.ReactNode }): JSX.Element {
    return typeof description === 'string' ? (
        <LemonMarkdown className="definition-popover-description" lowKeyHeadings>
            {description}
        </LemonMarkdown>
    ) : (
        <div className="definition-popover-description">{description}</div>
    )
}

function DescriptionEmpty(): JSX.Element {
    const { singularType } = useValues(definitionPopoverLogic)
    return <div className="definition-popover-description empty">Add a description for this {singularType}</div>
}

function Example({ value }: { value?: string }): JSX.Element {
    const { type, mediaPreviews } = useValues(definitionPopoverLogic)

    let data: CoreFilterDefinition | null = null

    if (
        // NB: also update "selectedItemHasPopover" below
        type === TaxonomicFilterGroupType.Events ||
        type === TaxonomicFilterGroupType.EventProperties ||
        type === TaxonomicFilterGroupType.EventFeatureFlags ||
        type === TaxonomicFilterGroupType.PersonProperties ||
        type === TaxonomicFilterGroupType.GroupsPrefix ||
        type === TaxonomicFilterGroupType.Metadata ||
        type === TaxonomicFilterGroupType.SessionProperties
    ) {
        data = getCoreFilterDefinition(value, type)
    } else if (type === TaxonomicFilterGroupType.Elements) {
        data = getCoreFilterDefinition(value, type)
    }

    const textExample = data?.examples?.[0] ? (
        <div className="definition-popover-examples">Example: {data?.examples?.join(', ')}</div>
    ) : (
        <></>
    )

    const hasContent = data?.examples?.[0] || mediaPreviews.length > 0

    return (
        <div className={clsx('flex flex-col gap-2', hasContent && 'mb-4')}>
            {textExample}
            <ImageCarousel imageUrls={mediaPreviews} />
        </div>
    )
}

function TimeMeta({
    createdAt,
    createdBy,
    updatedAt,
    updatedBy,
}: {
    createdAt?: string
    createdBy?: UserBasicType
    updatedAt?: string
    updatedBy?: UserBasicType
}): JSX.Element {
    // If updatedAt doesn't exist, fallback on showing creator
    if (updatedAt) {
        return (
            <div className="definition-popover-timemeta">
                <span className="definition-popover-timemeta-time">
                    Last modified {dayjs().to(dayjs.utc(updatedAt))}{' '}
                </span>
                {updatedBy && (
                    <span className="definition-popover-timemeta-user">
                        <span className="definition-popover-timemeta-spacer">by</span>
                        <Owner user={updatedBy} />
                    </span>
                )}
            </div>
        )
    }
    if (createdAt) {
        return (
            <div className="definition-popover-timemeta">
                <span className="definition-popover-timemeta-time">Created {dayjs().to(dayjs.utc(createdAt))} </span>
                {updatedBy && (
                    <span className="definition-popover-timemeta-user">
                        <span className="definition-popover-timemeta-spacer">by</span> <Owner user={createdBy} />
                    </span>
                )}
            </div>
        )
    }
    return <></>
}

function Owner({ user }: { user?: UserBasicType | null }): JSX.Element {
    return (
        <>
            {user?.uuid ? (
                <div className="flex items-center flex-row">
                    <ProfilePicture user={user} size="sm" />
                    <span className="pl-2 inline-flex font-semibold whitespace-nowrap">{user.first_name}</span>
                </div>
            ) : (
                <span className="text-secondary italic inline-flex font-semibold pl-1 whitespace-nowrap">No owner</span>
            )}
        </>
    )
}

function HorizontalLine({ className, label }: { className?: string; label?: string }): JSX.Element {
    return (
        <LemonDivider
            className={clsx('DefinitionPopover items-start my-4', className)}
            label={label && <span className="DefinitionPopover__label">{label}</span>}
        />
    )
}

function Section({ children }: { children: React.ReactNode }): JSX.Element {
    return <DefinitionPopoverGrid cols={1}>{children}</DefinitionPopoverGrid>
}

export const DefinitionPopover = {
    Wrapper,
    Header,
    Description,
    DescriptionEmpty,
    Example,
    TimeMeta,
    HorizontalLine,
    Grid: DefinitionPopoverGrid,
    Section,
    Card: DefinitionPopoverCard,
}