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.

8.3 KB
Raw Blame
import { ReactNode } from 'react'

import { MetricDirectionColorPickers } from 'lib/components/Metric/MetricDirectionColorPickers'

import { ChartOptionNumberInput } from './ChartOptionNumberInput'
import { ChartOptionSelect } from './ChartOptionSelect'
import { ChartOptionSwitch } from './ChartOptionSwitch'
import { ChartOptionTextInput } from './ChartOptionTextInput'
import { ChartOptionToggleGroup } from './ChartOptionToggleGroup'
import { ChartOptionWarning } from './ChartOptionWarning'
import {
    DISPLAY_OPTION_GROUPS,
    DISPLAY_OPTION_TABS,
    DISPLAY_OPTIONS,
    DisplayOptionBinding,
    DisplayOptionBindings,
    DisplayOptionDefinition,
    DisplayOptionGroupKey,
    DisplayOptionItem,
    DisplayOptionSection,
    DisplayOptionTab,
    DirectionColors,
} from './displayOptions'

type AnyBinding<C> = DisplayOptionBinding<C, any>

export interface DisplayOptionGroupOverride {
    title?: string
}

export interface BuildDisplayOptionsSettings {
    // Lists every group under one tab, for a surface with too few options to need tabs.
    singleTab?: boolean
    groups?: Partial<Record<DisplayOptionGroupKey, DisplayOptionGroupOverride>>
}

function renderControl<C>(definition: DisplayOptionDefinition, binding: AnyBinding<C>, c: C): ReactNode {
    if (binding.render) {
        return binding.render(c)
    }
    const label = definition.label
    const visibleLabel = definition.hideLabel || definition.stacked ? undefined : label
    const value = binding.value?.(c)
    const onChange = (next: unknown): void => binding.onChange?.(next, c)
    const disabledReason = binding.disabledReason?.(c) ?? undefined
    const dataAttr = binding.dataAttr

    switch (definition.control) {
        case 'checkbox':
            return (
                <ChartOptionSwitch
                    label={label}
                    info={definition.info}
                    checked={!!value}
                    onChange={onChange}
                    disabledReason={disabledReason}
                    data-attr={dataAttr}
                />
            )
        case 'number':
            return (
                <ChartOptionNumberInput
                    label={label}
                    info={definition.info}
                    value={value}
                    min={definition.min}
                    max={definition.max}
                    suffix={binding.suffix?.(c) ?? definition.suffix}
                    placeholder={binding.placeholder?.(c) ?? definition.placeholder}
                    disabledReason={disabledReason}
                    onChange={onChange}
                    data-attr={dataAttr}
                />
            )
        case 'text':
            return (
                <ChartOptionTextInput
                    label={visibleLabel}
                    info={definition.info}
                    value={value}
                    placeholder={binding.placeholder?.(c) ?? definition.placeholder}
                    onChange={onChange}
                    data-attr={dataAttr}
                />
            )
        case 'select':
        case 'toggle': {
            const Control = definition.control === 'select' ? ChartOptionSelect : ChartOptionToggleGroup
            return (
                <Control
                    label={visibleLabel}
                    info={definition.info}
                    value={value}
                    options={binding.options?.(c) ?? [...(definition.options ?? [])]}
                    onChange={onChange}
                    disabledReason={disabledReason}
                    data-attr={dataAttr}
                />
            )
        }
        case 'colors': {
            const colors = value as DirectionColors
            return (
                <MetricDirectionColorPickers
                    className="gap-2"
                    increaseColor={colors.increase}
                    decreaseColor={colors.decrease}
                    onIncrease={(increase) => onChange({ ...colors, increase })}
                    onDecrease={(decrease) => onChange({ ...colors, decrease })}
                />
            )
        }
        case 'custom':
            return null
    }
}

function renderOption<C>(definition: DisplayOptionDefinition, binding: AnyBinding<C>, c: C): ReactNode {
    const control = renderControl(definition, binding, c)
    const warning = binding.warning?.(c)
    const content = warning ? (
        <>
            {control}
            <ChartOptionWarning>{warning}</ChartOptionWarning>
        </>
    ) : (
        control
    )
    return definition.nested ? <div className="pl-4">{content}</div> : content
}

// Turns one surface's bindings into tabs → sections → rendered options, in the shared order.
// `count` is the number of options set away from their default, badged on the Options button.
export function buildDisplayOptions<C>(
    bindings: DisplayOptionBindings<C>,
    c: C,
    { singleTab = false, groups: overrides = {} }: BuildDisplayOptionsSettings = {}
): { tabs: DisplayOptionTab[]; count: number } {
    const definitions: readonly DisplayOptionDefinition[] = DISPLAY_OPTIONS
    const shownByGroup = new Map<
        DisplayOptionGroupKey,
        { definition: DisplayOptionDefinition; item: DisplayOptionItem }[]
    >()
    const countByGroup = new Map<DisplayOptionGroupKey, number>()

    for (const definition of definitions) {
        const name = definition.name as keyof DisplayOptionBindings<C>
        const binding = bindings[name] as AnyBinding<C> | undefined
        if (!binding || !binding.showCondition(c)) {
            continue
        }
        const group = definition.group
        const changed = Number(binding.changedCount?.(c) ?? 0)
        shownByGroup.set(group, [
            ...(shownByGroup.get(group) ?? []),
            {
                definition,
                item: {
                    name,
                    element: renderOption(definition, binding, c),
                    changed,
                    advanced: !!definition.advanced,
                },
            },
        ])
        countByGroup.set(group, (countByGroup.get(group) ?? 0) + changed)
    }

    const groupSections = (group: (typeof DISPLAY_OPTION_GROUPS)[number]): DisplayOptionSection[] => {
        const sections: DisplayOptionSection[] = []
        let run: DisplayOptionItem[] = []
        const flushRun = (): void => {
            if (run.length === 0) {
                return
            }
            const isFirstRun = !sections.some((section) => section.key === group.key)
            sections.push(
                isFirstRun
                    ? {
                          key: group.key,
                          group: group.key,
                          title: overrides[group.key]?.title ?? ('title' in group ? group.title : undefined),
                          dataAttr: 'dataAttr' in group ? group.dataAttr : undefined,
                          items: run,
                      }
                    : { key: `${group.key}-${sections.length}`, group: group.key, items: run }
            )
            run = []
        }
        for (const { definition, item } of shownByGroup.get(group.key) ?? []) {
            if (definition.stacked) {
                flushRun()
                sections.push({
                    key: definition.name,
                    group: group.key,
                    title: definition.label,
                    tooltip: definition.info,
                    items: [item],
                })
            } else {
                run.push(item)
            }
        }
        flushRun()
        return sections
    }

    const allTabs: DisplayOptionTab[] = DISPLAY_OPTION_TABS.map((tab) => {
        const groups = DISPLAY_OPTION_GROUPS.filter((group) => group.tab === tab.key)
        const sections = groups.flatMap(groupSections)
        const count = groups.reduce((sum, group) => sum + (countByGroup.get(group.key) ?? 0), 0)
        return { key: tab.key, label: tab.label, sections, count }
    })

    const tabs = (
        singleTab
            ? [
                  {
                      key: 'general' as const,
                      label: 'General',
                      sections: allTabs.flatMap((tab) => tab.sections),
                      count: allTabs.reduce((sum, tab) => sum + tab.count, 0),
                  },
              ]
            : allTabs
    ).filter((tab) => tab.sections.length > 0)

    return { tabs, count: tabs.reduce((sum, tab) => sum + tab.count, 0) }
}