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.

84.3 KB
Raw Blame
import {
    MakeLogicType,
    actions,
    afterMount,
    connect,
    kea,
    key,
    listeners,
    path,
    props,
    propsChanged,
    reducers,
    selectors,
    sharedListeners,
} from 'kea'
import type { BreakPointFunction } from 'kea'
import { subscriptions } from 'kea-subscriptions'
import mergeObject from 'lodash.merge'
import posthog from 'posthog-js'

import { PART_OF_WHOLE_DISPLAY_TYPES, PIE_DISPLAY_TYPES } from 'lib/constants'
import { dayjs } from 'lib/dayjs'
import type { execHog } from 'lib/hog'
import { RGBToHex, lightenDarkenColor } from 'lib/utils/colors'
import { uuid } from 'lib/utils/dom'
import { isChunkLoadError } from 'lib/utils/isChunkLoadError'
import { compactNumber } from 'lib/utils/numbers'
import { objectsEqual } from 'lib/utils/objects'
import { retryImport } from 'lib/utils/retryImport'
import { sceneLogic } from 'scenes/sceneLogic'
import { Scene } from 'scenes/sceneTypes'
import { teamLogic } from 'scenes/teamLogic'

import { themeLogic } from '~/layout/navigation-3000/themeLogic'
import {
    AnyResponseType,
    ChartAxis,
    ChartSettings,
    ChartSettingsDisplay,
    ChartSettingsFormatting,
    DashboardFilter,
    ConditionalFormattingRule,
    VisualizationNode,
    NodeKind,
    HeatmapSettings,
    HogQLVariable,
} from '~/queries/schema/schema-general'
import { QueryContext } from '~/queries/types'
import { ChartDisplayType, DashboardType } from '~/types'

import { captureBIWorksheetAction } from 'products/business_intelligence/frontend/biEditorAnalytics'
import { getBIResultDimensions } from 'products/business_intelligence/frontend/biEditorTypes'
import { getBIAutoChartType } from 'products/business_intelligence/frontend/biEditorTypes'
import { createBIMemberDisplayLookup } from 'products/business_intelligence/frontend/biMemberAliases'
import {
    getBISeriesSettings,
    getBIVisualizationResponse,
    getBIVisualizationSource,
} from 'products/business_intelligence/frontend/biQueryResults'
import { isBIPivotTable } from 'products/business_intelligence/frontend/biTableLayout'

import type {
    DataNode,
    ErrorTrackingQueryResponse,
    HogQLAutocompleteResponse,
    HogQLMetadataResponse,
    HogQLQueryResponse,
    HogQueryResponse,
    LogAttributesQueryResponse,
    LogValuesQueryResponse,
    MetricsQueryResponse,
    RefreshType,
    SessionsQueryResponse,
    TraceSpansAggregationQueryResponse,
    TraceSpansAttributeBreakdownQueryResponse,
    TraceSpansQueryResponse,
} from '../../schema/schema-general'
import type { TraceSpansTreeQueryResponse } from '../../schema/schema-general'
import { DataNodeLogicProps, dataNodeLogic } from '../DataNode/dataNodeLogic'
import { QueryFeature, getQueryFeatures } from '../DataTable/queryFeatures'
import { getAutoBoxPlotSettings } from './Components/Charts/sqlBoxPlotAdapter'
import { humanizeEventColumnValue } from './eventColumnLabels'
import { ColumnScalar, FORMATTING_TEMPLATES } from './types'

export enum SideBarTab {
    Series = 'series',
    Display = 'display',
    ConditionalFormatting = 'conditional_formatting',
}

export interface ColumnType {
    name: ColumnScalar
    isNumerical: boolean
}

export interface Column {
    name: string
    type: ColumnType
    label: string
    dataIndex: number
}

export interface TableRow {
    rowIndex: number
}

export interface TableDataCell<T extends string | number | boolean | Date | null> {
    value: T
    formattedValue: string | object | null
    type: ColumnScalar
    sourceColumnName?: string
    isTransposedHeader?: boolean
}

export interface AxisSeriesSettings {
    formatting?: ChartSettingsFormatting
    display?: ChartSettingsDisplay
}

export interface AxisSeries<T> {
    column: Column
    data: T[]
    settings?: AxisSeriesSettings
}

export interface DataVisualizationLogicProps {
    loadQueue?: DataNodeLogicProps['loadQueue']
    key: string
    query: VisualizationNode
    editMode?: boolean
    dataNodeCollectionId: string
    setQuery?: (setter: (node: VisualizationNode) => VisualizationNode) => void
    context?: QueryContext<VisualizationNode>
    cachedResults?: AnyResponseType
    insightLoading?: boolean
    dashboardId?: DashboardType['id']
    loadPriority?: number
    retainResponseOnUnmount?: boolean
    /** Dashboard variables to override the ones in the query */
    variablesOverride?: Record<string, HogQLVariable> | null
    filtersOverride?: DashboardFilter | null
    limitContext?: 'posthog_ai'
}

export interface SelectedYAxis {
    name: string
    settings: AxisSeriesSettings
}

export const EmptyYAxisSeries: AxisSeries<number> = {
    column: {
        name: 'None',
        type: {
            name: 'INTEGER',
            isNumerical: false,
        },
        label: 'None',
        dataIndex: -1,
    },
    data: [],
}

const DefaultAxisSettings = (): AxisSeriesSettings => ({
    formatting: {
        prefix: '',
        suffix: '',
    },
})

/** Deep clone settings to prevent shared references between Y-axis entries */
const cloneSettings = (settings: AxisSeriesSettings): AxisSeriesSettings =>
    mergeObject({}, settings) as AxisSeriesSettings

const cloneOrDefaultSettings = (settings?: AxisSeriesSettings): AxisSeriesSettings =>
    settings ? cloneSettings(settings) : DefaultAxisSettings()

const TRANSPOSED_FIELD_COLUMN_NAME = '__transpose_field__'
const TRANSPOSED_ROW_COLUMN_PREFIX = '__transpose_row__'

export const formatDataWithSettings = (
    data: number | string | null | object,
    settings?: AxisSeriesSettings
): string | object | null => {
    if (data === null || Number.isNaN(data)) {
        return null
    }

    if (typeof data === 'object') {
        return data
    }

    const decimalPlaces = settings?.formatting?.decimalPlaces

    let dataAsString = `${data}`

    if (typeof data === 'number') {
        dataAsString = `${decimalPlaces != null ? data.toFixed(decimalPlaces) : data}`

        if (settings?.formatting?.style === 'number') {
            dataAsString = data.toLocaleString(undefined, {
                minimumFractionDigits: decimalPlaces,
                maximumFractionDigits: decimalPlaces,
            })
        }

        if (settings?.formatting?.style === 'short') {
            dataAsString = compactNumber(data)
        }

        if (settings?.formatting?.style === 'percent') {
            dataAsString = `${data.toLocaleString(undefined, { minimumFractionDigits: decimalPlaces, maximumFractionDigits: decimalPlaces })}%`
        }
    }

    if (settings?.formatting?.prefix) {
        dataAsString = `${settings.formatting.prefix}${dataAsString}`
    }

    if (settings?.formatting?.suffix) {
        dataAsString = `${dataAsString}${settings.formatting.suffix}`
    }

    return dataAsString
}

export const convertTableValue = (
    value: string | number | null,
    type: ColumnScalar
): string | number | boolean | null => {
    if (value == null) {
        return null
    }

    if (type === 'STRING') {
        return value.toString()
    }

    if (type === 'INTEGER') {
        if (typeof value === 'number') {
            return value
        }

        return parseInt(value)
    }

    if (type === 'FLOAT' || type === 'DECIMAL') {
        if (typeof value === 'number') {
            return value
        }

        return parseFloat(value)
    }

    if (type === 'BOOLEAN') {
        return Boolean(value)
    }

    if (type === 'DATE' || type === 'DATETIME') {
        return dayjs(value).unix()
    }

    return value
}

const toFriendlyClickhouseTypeName = (type: string | undefined): ColumnScalar => {
    if (!type) {
        return 'UNKNOWN'
    }

    if (type.indexOf('Array') !== -1) {
        return 'ARRAY'
    }
    if (type.indexOf('Tuple') !== -1) {
        return 'TUPLE'
    }
    if (type.indexOf('Int') !== -1) {
        return 'INTEGER'
    }
    if (type.indexOf('Float') !== -1) {
        return 'FLOAT'
    }
    if (type.indexOf('DateTime') !== -1) {
        return 'DATETIME'
    }
    if (type.indexOf('Date') !== -1) {
        return 'DATE'
    }
    if (type.indexOf('Boolean') !== -1) {
        return 'BOOLEAN'
    }
    if (type.indexOf('Decimal') !== -1) {
        return 'DECIMAL'
    }
    if (type.indexOf('String') !== -1) {
        return 'STRING'
    }

    return type as ColumnScalar
}

const isNumericalType = (type: ColumnScalar): boolean => {
    if (type === 'INTEGER' || type === 'FLOAT' || type === 'DECIMAL') {
        return true
    }

    return false
}

const columnsFromResponseFields = (columns: string[] = [], types: string[][] = []): Column[] => {
    return columns.map((column, index) => {
        const type = types[index]?.[1]
        const friendlyClickhouseTypeName = toFriendlyClickhouseTypeName(type)

        return {
            name: column,
            type: {
                name: friendlyClickhouseTypeName,
                isNumerical: isNumericalType(friendlyClickhouseTypeName),
            },
            label: `${column} - ${type}`,
            dataIndex: index,
        }
    })
}

export const columnsFromResponse = (response: AnyResponseType | null): Column[] => {
    if (!response) {
        return []
    }

    return columnsFromResponseFields(
        'columns' in response && Array.isArray(response.columns) ? response.columns : [],
        'types' in response && Array.isArray(response.types) ? response.types : []
    )
}

const deriveDefaultAxes = (columns: Column[]): { xAxis: string | null; yAxis: string[] } => {
    const dateColumn = columns.find((column) => column.type.name.indexOf('DATE') !== -1)
    const numericalColumns = columns.filter((column) => column.type.isNumerical)
    const yAxis = numericalColumns.map((column) => column.name)

    if (dateColumn) {
        return { xAxis: dateColumn.name, yAxis }
    }

    const claimed = new Set(yAxis)
    return { xAxis: columns.find((column) => !claimed.has(column.name))?.name ?? null, yAxis }
}

const resolveNonTimeSeriesVisualizationType = (columns: Column[]): ChartDisplayType => {
    const stringColumns = columns.filter((column) => column.type.name === 'STRING')
    const numericalColumns = columns.filter((column) => column.type.isNumerical)

    if (stringColumns.length >= 2 && numericalColumns.length >= 1) {
        return ChartDisplayType.TwoDimensionalHeatmap
    }

    if (numericalColumns.length === 1 && columns.length === 1) {
        return ChartDisplayType.BoldNumber
    }

    if (numericalColumns.length > 0) {
        return ChartDisplayType.ActionsBar
    }

    return ChartDisplayType.ActionsTable
}

export const rowCountFromResponse = (response: AnyResponseType | null): number => {
    const rawResults =
        response && 'results' in response ? response.results : response && 'result' in response ? response.result : []
    return Array.isArray(rawResults) ? rawResults.length : 0
}

const hasTimeSeriesData = (columns: Column[], rowCount: number): boolean => {
    const hasDateColumn = columns.some((column) => ['DATE', 'DATETIME'].includes(column.type.name))
    const hasNumericColumn = columns.some((column) => column.type.isNumerical)

    return hasDateColumn && hasNumericColumn && rowCount > 1
}

export const getAutoVisualizationType = (columns: Column[], rowCount: number): ChartDisplayType => {
    if (hasTimeSeriesData(columns, rowCount)) {
        return ChartDisplayType.ActionsLineGraph
    }

    return resolveNonTimeSeriesVisualizationType(columns)
}

const getHeatmapAutoSettings = (columns: Column[], heatmapSettings: HeatmapSettings): Partial<HeatmapSettings> => {
    const stringColumns = columns.filter((column) => column.type.name === 'STRING')
    const numericalColumns = columns.filter((column) => column.type.isNumerical)

    const nextSettings: Partial<HeatmapSettings> = {}

    if (!heatmapSettings.xAxisColumn && stringColumns[0]) {
        nextSettings.xAxisColumn = stringColumns[0].name
    }

    if (!heatmapSettings.yAxisColumn && stringColumns[1]) {
        nextSettings.yAxisColumn = stringColumns[1].name
    }

    if (!heatmapSettings.valueColumn && numericalColumns[0]) {
        nextSettings.valueColumn = numericalColumns[0].name
    }

    return nextSettings
}

const applyAutoHeatmapSettings = (
    actions: { updateChartSettings: (settings: ChartSettings) => void },
    columns: Column[],
    heatmapSettings: HeatmapSettings
): void => {
    const autoSettings = getHeatmapAutoSettings(columns, heatmapSettings)

    if (Object.keys(autoSettings).length === 0) {
        return
    }

    actions.updateChartSettings({
        heatmap: {
            ...heatmapSettings,
            ...autoSettings,
        },
    })
}

const mergeChartSettings = (state: ChartSettings, settings: ChartSettings): ChartSettings => {
    return {
        ...state,
        ...settings,
        heatmap:
            state.heatmap || settings.heatmap
                ? {
                      ...state.heatmap,
                      ...settings.heatmap,
                  }
                : undefined,
        pie:
            state.pie || settings.pie
                ? {
                      ...state.pie,
                      ...settings.pie,
                  }
                : undefined,
        scatter:
            state.scatter || settings.scatter
                ? {
                      ...state.scatter,
                      ...settings.scatter,
                  }
                : undefined,
        boxPlot:
            state.boxPlot || settings.boxPlot
                ? {
                      ...state.boxPlot,
                      ...settings.boxPlot,
                  }
                : undefined,
        metric:
            state.metric || settings.metric
                ? {
                      ...state.metric,
                      ...settings.metric,
                  }
                : undefined,
        leftYAxisSettings:
            state.leftYAxisSettings || settings.leftYAxisSettings
                ? {
                      ...state.leftYAxisSettings,
                      ...settings.leftYAxisSettings,
                  }
                : undefined,
        rightYAxisSettings:
            state.rightYAxisSettings || settings.rightYAxisSettings
                ? {
                      ...state.rightYAxisSettings,
                      ...settings.rightYAxisSettings,
                  }
                : undefined,
        chartStyle:
            state.chartStyle || settings.chartStyle
                ? {
                      ...state.chartStyle,
                      ...settings.chartStyle,
                  }
                : undefined,
    }
}

const shouldUseFirstNumericColumnAsContinuousChartXAxis = (
    columns: Column[],
    numericalColumns: Column[],
    selectedXAxis: string | null,
    selectedYAxis: (Pick<SelectedYAxis, 'name'> | null)[] | null
): boolean => {
    if (selectedXAxis !== null || columns.length < 2 || numericalColumns.length < 2) {
        return false
    }

    if (!columns.every((column) => column.type.isNumerical)) {
        return false
    }

    if (!selectedYAxis || selectedYAxis.length !== numericalColumns.length) {
        return false
    }

    const selectedYAxisNames = new Set(selectedYAxis.map((series) => series?.name))

    return numericalColumns.every((column) => selectedYAxisNames.has(column.name))
}

const resolveScatterXAxisColumn = (
    columns: Column[],
    numericalColumns: Column[],
    selectedXAxis: string | null,
    selectedYAxis: (Pick<SelectedYAxis, 'name'> | null)[] | null
): Column | null => {
    if (numericalColumns.length < 2) {
        return null
    }

    const currentXAxis = columns.find((column) => column.name === selectedXAxis)
    if (currentXAxis?.type.isNumerical) {
        return currentXAxis
    }

    const selectedYAxisNames = new Set((selectedYAxis ?? []).map((series) => series?.name))
    return numericalColumns.find((column) => !selectedYAxisNames.has(column.name)) ?? numericalColumns[0]
}

export function applyVisualizationType(
    query: VisualizationNode,
    visualizationType: ChartDisplayType,
    columns: Column[],
    rowCount: number
): VisualizationNode {
    const numericalColumns = columns.filter((column) => column.type.isNumerical)
    const chartSettings: ChartSettings = { ...query.chartSettings }

    const columnNames = new Set(columns.map((column) => column.name))
    const invalidX = chartSettings.xAxis !== undefined && !columnNames.has(chartSettings.xAxis.column)
    const invalidY =
        chartSettings.yAxis?.some(
            (series) => !columns.find((column) => column.name === series.column)?.type.isNumerical
        ) ?? false

    if (columns.length > 0 && (invalidX || invalidY)) {
        chartSettings.xAxis = undefined
        chartSettings.yAxis = undefined
    }

    // An empty yAxis records that the user deleted every series, so only absent axes are seeded.
    if (chartSettings.xAxis === undefined && chartSettings.yAxis === undefined) {
        const seeded = deriveDefaultAxes(columns)
        if (seeded.yAxis.length > 0) {
            chartSettings.yAxis = seeded.yAxis.map((column) => ({ column, settings: DefaultAxisSettings() }))
        }
        if (seeded.xAxis) {
            chartSettings.xAxis = { column: seeded.xAxis }
        }
    }

    const selectedXAxis = chartSettings.xAxis?.column ?? null
    let yAxis = chartSettings.yAxis ? [...chartSettings.yAxis] : []
    const selectedYAxis = yAxis.map((series) => ({ name: series.column }))

    if (PIE_DISPLAY_TYPES.includes(visualizationType) && chartSettings.pie?.sliceContent === undefined) {
        chartSettings.pie = { ...chartSettings.pie, sliceContent: 'labels' }
    }

    if (visualizationType === ChartDisplayType.ActionsDonut && chartSettings.pie?.showTotal === undefined) {
        chartSettings.pie = { ...chartSettings.pie, showTotal: true }
    }

    if (visualizationType === ChartDisplayType.Metric) {
        yAxis = yAxis.slice(0, 1)
    }

    // With several values a part-of-whole chart draws one part per column and ignores the x-axis, so a
    // numeric column a line or scatter chart moved onto the x-axis goes back to the values. A series
    // breakdown still needs the x-axis, so it stays then.
    const numericXAxisColumn = numericalColumns.find((column) => column.name === selectedXAxis)
    if (
        PART_OF_WHOLE_DISPLAY_TYPES.includes(visualizationType) &&
        !chartSettings.seriesBreakdownColumn &&
        yAxis.length > 1 &&
        numericXAxisColumn &&
        !yAxis.some((series) => series.column === numericXAxisColumn.name)
    ) {
        yAxis = [{ column: numericXAxisColumn.name, settings: DefaultAxisSettings() }, ...yAxis]
        chartSettings.xAxis = undefined
    }

    if (
        [ChartDisplayType.ActionsLineGraph, ChartDisplayType.ActionsAreaGraph].includes(visualizationType) &&
        shouldUseFirstNumericColumnAsContinuousChartXAxis(columns, numericalColumns, selectedXAxis, selectedYAxis)
    ) {
        const [xAxisColumn] = numericalColumns
        chartSettings.xAxis = { column: xAxisColumn.name }
        yAxis = yAxis.filter((series) => series.column !== xAxisColumn.name)
    }

    if (visualizationType === ChartDisplayType.ScatterPlot) {
        const xAxisColumn = resolveScatterXAxisColumn(columns, numericalColumns, selectedXAxis, selectedYAxis)
        if (xAxisColumn) {
            chartSettings.xAxis = { column: xAxisColumn.name }
            yAxis = yAxis.filter((series) => series.column !== xAxisColumn.name)
        }
    }

    if (visualizationType === ChartDisplayType.BoxPlot) {
        chartSettings.boxPlot = getAutoBoxPlotSettings(columns, chartSettings.boxPlot)
    }

    const isAutoHeatmap =
        visualizationType === ChartDisplayType.Auto &&
        getAutoVisualizationType(columns, rowCount) === ChartDisplayType.TwoDimensionalHeatmap

    if (visualizationType === ChartDisplayType.TwoDimensionalHeatmap || isAutoHeatmap) {
        const heatmap = chartSettings.heatmap ?? {}
        const autoSettings = getHeatmapAutoSettings(columns, heatmap)
        if (Object.keys(autoSettings).length > 0) {
            chartSettings.heatmap = { ...heatmap, ...autoSettings }
        }
    }

    if (chartSettings.yAxis !== undefined) {
        chartSettings.yAxis = yAxis
    }

    return { ...query, display: visualizationType, chartSettings }
}

/**
 * Establishes the scatter x-axis invariant: a numeric column on the x axis that isn't also a
 * y-series. Runs from every entry path a scatter can arrive through, including column changes and
 * persisted or assistant-created insights, so the chart never
 * renders blank or plots a column against itself. A no-op when there's nothing to fix.
 */
const applyScatterXAxis = (
    actions: {
        updateXSeries: (columnName: string) => void
        deleteYSeries: (seriesIndex: number) => void
    },
    columns: Column[],
    selectedXAxis: string | null,
    selectedYAxis: (SelectedYAxis | null)[] | null
): void => {
    const numericalColumns = columns.filter((column) => column.type.isNumerical)
    const xAxisColumn = resolveScatterXAxisColumn(columns, numericalColumns, selectedXAxis, selectedYAxis)
    if (!xAxisColumn) {
        return
    }

    if (xAxisColumn.name !== selectedXAxis) {
        actions.updateXSeries(xAxisColumn.name)
    }

    // updateXSeries doesn't touch the y-series array, so this index stays valid.
    const xAxisSeriesIndex = selectedYAxis?.findIndex((series) => series?.name === xAxisColumn.name) ?? -1
    if (xAxisSeriesIndex > -1) {
        actions.deleteYSeries(xAxisSeriesIndex)
    }
}

// A named interface, because kea-typegen writes `typeof import('lib/hog')` as an absolute path.
interface HogVm {
    execHog: typeof execHog
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataVisualizationLogicValues {
    queryCancelled: boolean // dataNodeLogic
    rawHasMoreData: boolean // dataNodeLogic
    rawResponse:
        | ErrorTrackingQueryResponse
        | HogQLAutocompleteResponse
        | HogQLMetadataResponse
        | HogQLQueryResponse<any[]>
        | HogQueryResponse
        | LogAttributesQueryResponse
        | LogValuesQueryResponse
        | MetricsQueryResponse
        | Record<string, any>
        | SessionsQueryResponse
        | TraceSpansAggregationQueryResponse
        | TraceSpansAttributeBreakdownQueryResponse
        | TraceSpansQueryResponse
        | TraceSpansTreeQueryResponse
        | null // dataNodeLogic
    responseError: string | null // dataNodeLogic
    responseLoading: boolean // dataNodeLogic
    activeSceneId: string | null // sceneLogic
    currentTeamId: number | null // teamLogic
    isDarkModeOn: boolean // themeLogic
    activeSideBarTab: SideBarTab
    autoVisualizationType: ChartDisplayType
    chartSettings: ChartSettings
    columns: Column[]
    conditionalFormattingRules: ConditionalFormattingRule[]
    conditionalFormattingRulesPanelActiveKeys: string[]
    dashboardId: any
    dataVisualizationProps: DataVisualizationLogicProps
    effectiveVisualizationType: ChartDisplayType
    getSourceTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>
    getTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>
    hasDateTimeColumns: boolean
    hasMoreData: boolean
    hasSortedTable: boolean
    hogVm: HogVm | null
    hogVmLoadError: unknown
    hogVmLoadFailed: boolean
    isChartSettingsPanelOpen: boolean
    isColumnPinned: (columnName: string) => boolean
    isPinningEnabled: boolean
    isShowingCachedResults: boolean
    isTableVisualization: boolean
    isTransposed: boolean
    needsHogVm: boolean
    numericalColumns: Column[]
    pinnedColumns: string[]
    presetChartHeight: boolean
    query: VisualizationNode
    response: AnyResponseType | null
    selectedXAxis: string | null
    selectedYAxis: (SelectedYAxis | null)[] | null
    showEditingUI: boolean
    showResultControls: boolean
    showTableSettings: boolean
    sourceFeatures: Set<QueryFeature>
    sourceTabularColumns: AxisSeries<any>[]
    tableResults: HogQLQueryResponse['results']
    tableRows: TableRow[]
    tabularColumnSettings: (SelectedYAxis | null)[] | null
    tabularColumns: AxisSeries<any>[]
    visualizationType: ChartDisplayType
    xData: AxisSeries<string> | null
    yData: AxisSeries<number | null>[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataVisualizationLogicActions {
    loadData: (
        refresh?: RefreshType | undefined,
        alreadyRunningQueryId?: string | undefined,
        overrideQuery?: DataNode<Record<string, any>> | undefined
    ) => {
        overrideQuery: DataNode<Record<string, any>> | undefined
        pollOnly: boolean
        queryId: string
        refresh: RefreshType | undefined
    } // dataNodeLogic
    _setQuery: (node: VisualizationNode) => {
        node: VisualizationNode
    }
    addConditionalFormattingRule: (rule?: ConditionalFormattingRule) => {
        isDarkModeOn: boolean
        rule:
            | ConditionalFormattingRule
            | {
                  id: string
              }
    }
    addYSeries: (
        columnName?: string,
        settings?: AxisSeriesSettings
    ) => {
        allNumericalColumns: Column[]
        columnName: string | undefined
        settings: AxisSeriesSettings | undefined
    }
    clearAxis: () => {
        value: true
    }
    deleteYSeries: (seriesIndex: number) => {
        seriesIndex: number
    }
    initializeAxes: (
        tabularColumns: SelectedYAxis[] | null,
        yAxis: SelectedYAxis[] | null,
        xAxis: string | null
    ) => {
        tabularColumns: SelectedYAxis[] | null
        xAxis: string | null
        yAxis: SelectedYAxis[] | null
    }
    loadHogVm: () => {
        value: true
    }
    setConditionalFormattingRulesPanelActiveKeys: (keys: string[]) => {
        keys: string[]
    }
    setHogVm: (hogVm: HogVm) => {
        hogVm: HogVm
    }
    setHogVmLoadError: (error: unknown) => {
        error: unknown
    }
    setQuery: (setter: (node: VisualizationNode) => VisualizationNode) => {
        setter: (node: VisualizationNode) => VisualizationNode
    }
    setSideBarTab: (tab: SideBarTab) => {
        tab: SideBarTab
    }
    setTableSorted: () => {
        value: true
    }
    setTransposeResults: (transpose: boolean) => {
        transpose: boolean
    }
    setVisualizationType: (visualizationType: ChartDisplayType) => {
        node: VisualizationNode
        visualizationType: ChartDisplayType
    }
    toggleChartSettingsPanel: (open?: boolean) => {
        open: boolean | undefined
    }
    toggleColumnPin: (columnName: string) => {
        columnName: string
    }
    updateChartSettings: (settings: ChartSettings) => {
        settings: ChartSettings
    }
    updateConditionalFormattingRule: (
        rule: ConditionalFormattingRule,
        deleteRule?: boolean
    ) => {
        colorMode: string
        deleteRule: boolean | undefined
        rule: ConditionalFormattingRule
    }
    updateSeries: (
        columnName: string,
        settings?: AxisSeriesSettings
    ) => {
        columnName: string
        settings: AxisSeriesSettings | undefined
    }
    updateSeriesIndex: (
        seriesIndex: number,
        columnName: string,
        settings?: AxisSeriesSettings
    ) => {
        columnName: string
        seriesIndex: number
        settings: AxisSeriesSettings | undefined
    }
    updateXSeries: (columnName: string) => {
        columnName: string
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface dataVisualizationLogicMeta {
    key: string
    sharedListeners: {
        axesChanged: (
            payload: any,
            breakpoint: BreakPointFunction,
            action: {
                type: string
                payload: any
            },
            previousState: any
        ) => void | Promise<void>
        conditionalFormattingRules: (
            payload: any,
            breakpoint: BreakPointFunction,
            action: {
                type: string
                payload: any
            },
            previousState: any
        ) => void | Promise<void>
        pinnedColumnsChanged: (
            payload: any,
            breakpoint: BreakPointFunction,
            action: {
                type: string
                payload: any
            },
            previousState: any
        ) => void | Promise<void>
    }
    __keaTypeGenInternalSelectorTypes: {
        response: (
            query: VisualizationNode,
            rawResponse:
                | ErrorTrackingQueryResponse
                | HogQLAutocompleteResponse
                | HogQLMetadataResponse
                | HogQLQueryResponse<any[]>
                | HogQueryResponse
                | LogAttributesQueryResponse
                | LogValuesQueryResponse
                | MetricsQueryResponse
                | Record<string, any>
                | SessionsQueryResponse
                | TraceSpansAggregationQueryResponse
                | TraceSpansAttributeBreakdownQueryResponse
                | TraceSpansQueryResponse
                | TraceSpansTreeQueryResponse
                | null
        ) => AnyResponseType | null
        hasMoreData: (response: AnyResponseType | null, rawHasMoreData: boolean) => boolean
        columns: (response: AnyResponseType | null) => Column[]
        numericalColumns: (columns: Column[]) => Column[]
        hasDateTimeColumns: (columns: Column[]) => boolean
        dashboardId: (arg: any) => any
        showEditingUI: (arg: boolean | undefined, dashboardId: any) => boolean
        showResultControls: (arg: boolean | undefined, dashboardId: any) => boolean
        presetChartHeight: (key: string, dashboardId: any, activeSceneId: string | null) => boolean
        sourceFeatures: (query: VisualizationNode) => Set<QueryFeature>
        isShowingCachedResults: (arg: any) => boolean
        isTransposed: (query: VisualizationNode) => boolean
        yData: (
            selectedYAxis: (SelectedYAxis | null)[] | null,
            response: AnyResponseType | null,
            columns: Column[],
            chartSettings: ChartSettings,
            effectiveVisualizationType: ChartDisplayType,
            query: VisualizationNode
        ) => AxisSeries<number | null>[]
        xData: (
            selectedXAxis: string | null,
            response: AnyResponseType | null,
            columns: Column[],
            query: VisualizationNode
        ) => AxisSeries<string> | null
        sourceTabularColumns: (
            tabularColumnSettings: (SelectedYAxis | null)[] | null,
            response: AnyResponseType | null,
            columns: Column[]
        ) => AxisSeries<any>[]
        tableResults: (response: AnyResponseType | null) => HogQLQueryResponse['results']
        getSourceTableCell: (
            sourceTabularColumns: AxisSeries<any>[],
            tableResults: any[],
            chartSettings: ChartSettings,
            query: VisualizationNode
        ) => (rowIndex: number, columnIndex: number) => TableDataCell<any>
        tabularColumns: (
            sourceTabularColumns: AxisSeries<any>[],
            tableResults: any[],
            isTransposed: boolean
        ) => AxisSeries<any>[]
        tableRows: (tableResults: any[], sourceTabularColumns: AxisSeries<any>[], isTransposed: boolean) => TableRow[]
        getTableCell: (
            getSourceTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>,
            sourceTabularColumns: AxisSeries<any>[],
            isTransposed: boolean
        ) => (rowIndex: number, columnIndex: number) => TableDataCell<any>
        dataVisualizationProps: (arg: any) => DataVisualizationLogicProps
        effectiveVisualizationType: (
            visualizationType: ChartDisplayType,
            autoVisualizationType: ChartDisplayType
        ) => ChartDisplayType
        autoVisualizationType: (
            columns: Column[],
            response: AnyResponseType | null,
            query: VisualizationNode
        ) => ChartDisplayType
        needsHogVm: (
            visualizationType: ChartDisplayType,
            effectiveVisualizationType: ChartDisplayType,
            columns: Column[],
            conditionalFormattingRules: ConditionalFormattingRule[],
            query: VisualizationNode
        ) => boolean
        hogVmLoadFailed: (needsHogVm: boolean, hogVmLoadError: unknown) => boolean
        isTableVisualization: (effectiveVisualizationType: ChartDisplayType) => boolean
        showTableSettings: (effectiveVisualizationType: ChartDisplayType) => boolean
        isColumnPinned: (pinnedColumns: string[]) => (columnName: string) => boolean
        isPinningEnabled: (activeSceneId: string | null, isTransposed: boolean) => boolean
    }
}

export type dataVisualizationLogicType = MakeLogicType<
    dataVisualizationLogicValues,
    dataVisualizationLogicActions,
    DataVisualizationLogicProps,
    dataVisualizationLogicMeta
>

export const dataVisualizationLogic = kea<dataVisualizationLogicType>([
    key((props) => props.key),
    path(['queries', 'nodes', 'DataVisualization', 'dataVisualizationLogic']),
    connect((props: DataVisualizationLogicProps) => ({
        values: [
            teamLogic,
            ['currentTeamId'],
            dataNodeLogic({
                loadQueue: props.loadQueue,
                cachedResults: props.cachedResults,
                key: props.key,
                query: getBIVisualizationSource(props.query),
                dataNodeCollectionId: props.dataNodeCollectionId,
                loadPriority: props.loadPriority,
                retainResponseOnUnmount: props.retainResponseOnUnmount,
                variablesOverride: props.variablesOverride,
                filtersOverride: props.filtersOverride,
                limitContext: props.limitContext,
            }),
            [
                'response as rawResponse',
                'responseLoading',
                'responseError',
                'queryCancelled',
                'hasMoreData as rawHasMoreData',
            ],
            themeLogic,
            ['isDarkModeOn'],
            sceneLogic,
            ['activeSceneId'],
        ],
        actions: [
            dataNodeLogic({
                loadQueue: props.loadQueue,
                cachedResults: props.cachedResults,
                retainResponseOnUnmount: props.retainResponseOnUnmount,
                key: props.key,
                query: getBIVisualizationSource(props.query),
                dataNodeCollectionId: props.dataNodeCollectionId,
                loadPriority: props.loadPriority,
                variablesOverride: props.variablesOverride,
                filtersOverride: props.filtersOverride,
                limitContext: props.limitContext,
            }),
            ['loadData'],
        ],
    })),
    afterMount(({ actions, props }) => {
        if (props.query) {
            // populate fields like tabularColumnSettings, etc
            actions._setQuery(props.query)
        }
    }),
    propsChanged(({ actions, values, props }, oldProps) => {
        // Without setQuery the internal query never equals props.query, so re-sync only when the prop changes.
        if (!props.setQuery && objectsEqual(props.query, oldProps.query)) {
            return
        }
        if (props.query && !objectsEqual(props.query, values.query)) {
            actions._setQuery(props.query)
        }
    }),
    props({ query: { source: {} } } as DataVisualizationLogicProps),
    actions(({ values }) => ({
        loadHogVm: true,
        setHogVm: (hogVm: HogVm) => ({ hogVm }),
        setHogVmLoadError: (error: unknown) => ({ error }),
        setVisualizationType: (visualizationType: ChartDisplayType) => ({
            visualizationType,
            node: applyVisualizationType(
                values.query,
                visualizationType,
                values.columns,
                rowCountFromResponse(values.response)
            ),
        }),
        updateXSeries: (columnName: string) => ({
            columnName,
        }),
        updateSeriesIndex: (seriesIndex: number, columnName: string, settings?: AxisSeriesSettings) => ({
            seriesIndex,
            columnName,
            settings,
        }),
        updateSeries: (columnName: string, settings?: AxisSeriesSettings) => ({ columnName, settings }),
        addYSeries: (columnName?: string, settings?: AxisSeriesSettings) => ({
            columnName,
            settings,
            allNumericalColumns: values.numericalColumns,
        }),
        deleteYSeries: (seriesIndex: number) => ({ seriesIndex }),
        initializeAxes: (
            tabularColumns: SelectedYAxis[] | null,
            yAxis: SelectedYAxis[] | null,
            xAxis: string | null
        ) => ({ tabularColumns, yAxis, xAxis }),
        clearAxis: true,
        setQuery: (setter: (node: VisualizationNode) => VisualizationNode) => ({ setter }),
        updateChartSettings: (settings: ChartSettings) => ({ settings }),
        setSideBarTab: (tab: SideBarTab) => ({ tab }),
        toggleChartSettingsPanel: (open?: boolean) => ({ open }),
        addConditionalFormattingRule: (rule?: ConditionalFormattingRule) => ({
            rule: rule ?? { id: uuid() },
            isDarkModeOn: values.isDarkModeOn,
        }),
        updateConditionalFormattingRule: (rule: ConditionalFormattingRule, deleteRule?: boolean) => ({
            rule,
            deleteRule,
            colorMode: values.isDarkModeOn ? 'dark' : 'light',
        }),
        setConditionalFormattingRulesPanelActiveKeys: (keys: string[]) => ({ keys }),
        toggleColumnPin: (columnName: string) => ({ columnName }),
        setTableSorted: true,
        setTransposeResults: (transpose: boolean) => ({ transpose }),
        _setQuery: (node: VisualizationNode) => ({ node }),
    })),
    reducers(({ props }) => ({
        hogVm: [null as HogVm | null, { setHogVm: (_, { hogVm }) => hogVm }],
        hogVmLoadError: [null as unknown, { setHogVmLoadError: (_, { error }) => error, setHogVm: () => null }],
        query: [
            props.query,
            {
                setQuery: (state, { setter }) => setter(state),
                setVisualizationType: (_, { node }) => node,
                _setQuery: (_, { node }) => node,
            },
        ],
        visualizationType: [
            props.query.display ?? ChartDisplayType.ActionsTable,
            {
                setVisualizationType: (_, { visualizationType }) => visualizationType,
                _setQuery: (_, { node }) => node.display ?? ChartDisplayType.ActionsTable,
            },
        ],
        tabularColumnSettings: [
            null as (SelectedYAxis | null)[] | null,
            {
                _setQuery: (state, { node }) => {
                    if (node.tableSettings?.columns) {
                        return node.tableSettings.columns.map((column) => ({
                            name: column.column,
                            settings: cloneOrDefaultSettings(column.settings),
                        }))
                    }
                    return state
                },
                clearAxis: () => null,
                initializeAxes: (state, { tabularColumns }) => tabularColumns ?? state,
                updateSeries: (state, { columnName, settings }) => {
                    if (!state) {
                        return null
                    }

                    const ySeries = [...state]

                    const index = ySeries.findIndex((n) => n?.name === columnName)
                    if (index < 0) {
                        return ySeries
                    }

                    ySeries[index] = {
                        name: columnName,
                        settings: mergeObject({}, ySeries[index]?.settings ?? {}, settings),
                    }
                    return ySeries
                },
                updateSeriesIndex: (state, { seriesIndex, columnName, settings }) => {
                    if (!state) {
                        return null
                    }

                    const ySeries = [...state]

                    ySeries[seriesIndex] = {
                        name: columnName,
                        settings: mergeObject({}, ySeries[seriesIndex]?.settings ?? {}, settings),
                    }
                    return ySeries
                },
            },
        ],
        selectedXAxis: [
            props.query.chartSettings?.xAxis?.column ?? null,
            {
                setVisualizationType: (_, { node }) => node.chartSettings?.xAxis?.column ?? null,
                _setQuery: (_, { node }) => node.chartSettings?.xAxis?.column ?? null,
                clearAxis: () => null,
                updateXSeries: (_, { columnName }) => columnName,
                initializeAxes: (state, { xAxis }) => xAxis ?? state,
            },
        ],
        selectedYAxis: [
            (props.query.chartSettings?.yAxis?.map((axis) => ({
                name: axis.column,
                settings: cloneOrDefaultSettings(axis.settings),
            })) ?? null) as (SelectedYAxis | null)[] | null,
            {
                setVisualizationType: (state, { node }) => {
                    if (node.chartSettings?.yAxis) {
                        return node.chartSettings.yAxis.map((axis) => ({
                            name: axis.column,
                            settings: cloneOrDefaultSettings(axis.settings),
                        }))
                    }
                    return state
                },
                _setQuery: (state, { node }) => {
                    if (node.chartSettings?.yAxis) {
                        return node.chartSettings.yAxis.map((axis) => ({
                            name: axis.column,
                            settings: cloneOrDefaultSettings(axis.settings),
                        }))
                    }
                    return state
                },
                clearAxis: () => null,
                initializeAxes: (state, { yAxis }) => yAxis ?? state,
                addYSeries: (state, { columnName, settings, allNumericalColumns }) => {
                    if (!state && columnName !== undefined) {
                        return [{ name: columnName, settings: settings ?? DefaultAxisSettings() }]
                    }

                    if (!state) {
                        return [null]
                    }

                    if (!columnName) {
                        const ungraphedColumns = allNumericalColumns.filter(
                            (n) => !state.map((m) => m?.name).includes(n.name)
                        )
                        if (ungraphedColumns.length > 0) {
                            return [
                                ...state,
                                { name: ungraphedColumns[0].name, settings: settings ?? DefaultAxisSettings() },
                            ]
                        }
                    }

                    return [
                        ...state,
                        columnName === undefined
                            ? null
                            : { name: columnName, settings: settings ?? DefaultAxisSettings() },
                    ]
                },
                updateSeriesIndex: (state, { seriesIndex, columnName, settings }) => {
                    if (!state) {
                        return null
                    }

                    const ySeries = [...state]

                    ySeries[seriesIndex] = {
                        name: columnName,
                        settings: mergeObject({}, ySeries[seriesIndex]?.settings ?? {}, settings),
                    }
                    return ySeries
                },
                updateSeries: (state, { columnName, settings }) => {
                    if (!state) {
                        return null
                    }

                    const ySeries = [...state]

                    const index = ySeries.findIndex((n) => n?.name === columnName)
                    if (index < 0) {
                        return ySeries
                    }

                    ySeries[index] = {
                        name: columnName,
                        settings: mergeObject({}, ySeries[index]?.settings ?? {}, settings),
                    }
                    return ySeries
                },
                deleteYSeries: (state, { seriesIndex }) => {
                    if (!state) {
                        return null
                    }

                    if (state.length <= 1) {
                        return [null]
                    }

                    const ySeries = [...state]

                    ySeries.splice(seriesIndex, 1)

                    return ySeries
                },
            },
        ],
        activeSideBarTab: [
            SideBarTab.Series as SideBarTab,
            {
                setSideBarTab: (_state, { tab }) => tab,
            },
        ],
        chartSettings: [
            props.query.chartSettings ?? ({} as ChartSettings),
            {
                setVisualizationType: (state, { node }) => node.chartSettings ?? state,
                _setQuery: (state, { node }) => node.chartSettings ?? state,
                updateChartSettings: (state, { settings }) => {
                    return mergeChartSettings(state, settings)
                },
            },
        ],
        isChartSettingsPanelOpen: [
            false as boolean,
            {
                toggleChartSettingsPanel: (state, { open }) => {
                    if (open === undefined) {
                        return !state
                    }

                    return open
                },
                setVisualizationType: (state, { visualizationType }) => {
                    if (state) {
                        return true
                    }

                    return visualizationType !== ChartDisplayType.ActionsTable
                },
            },
        ],
        conditionalFormattingRules: [
            [] as ConditionalFormattingRule[],
            {
                _setQuery: (state, { node }) => {
                    if (node.tableSettings?.conditionalFormatting) {
                        return node.tableSettings.conditionalFormatting
                    }
                    return state
                },
                addConditionalFormattingRule: (state, { rule, isDarkModeOn }) => {
                    const rules = [...state]

                    rules.push({
                        templateId: FORMATTING_TEMPLATES[0].id,
                        columnName: '',
                        bytecode: [],
                        input: '',
                        color: isDarkModeOn ? RGBToHex(lightenDarkenColor('#FFADAD', -30)) : '#FFADAD',
                        ...rule,
                    })

                    return rules
                },
                updateConditionalFormattingRule: (state, { rule, deleteRule, colorMode }) => {
                    const rules = [...state]

                    const index = rules.findIndex((n) => n.id === rule.id)
                    if (index === -1) {
                        return rules
                    }

                    if (deleteRule) {
                        rules.splice(index, 1)
                        return rules
                    }

                    rules[index] = { ...rule, colorMode: colorMode as 'light' | 'dark' }
                    return rules
                },
            },
        ],
        conditionalFormattingRulesPanelActiveKeys: [
            [] as string[],
            {
                _setQuery: (state, { node }) => {
                    if (node.tableSettings?.conditionalFormatting) {
                        return node.tableSettings.conditionalFormatting.map((n) => n.id)
                    }
                    return state
                },
                addConditionalFormattingRule: (state, { rule: { id } }) => {
                    return [...state, id]
                },
                setConditionalFormattingRulesPanelActiveKeys: (_, { keys }) => {
                    return [...keys]
                },
            },
        ],
        pinnedColumns: [
            [] as string[],
            {
                persist: true,
                // strips the dashboard suffix from the key so pinned columns persist across
                // dashboard and insight views
                storageKey: `data-visualization-pinned-columns-${props.key.split('/on-dashboard-')[0]}`,
            },
            {
                _setQuery: (state, { node }) => {
                    return node.tableSettings?.pinnedColumns ?? state
                },
                toggleColumnPin: (state, { columnName }) => {
                    if (state.includes(columnName)) {
                        return state.filter((k: string) => k !== columnName)
                    }
                    return [...state, columnName]
                },
            },
        ],
        hasSortedTable: [
            false,
            {
                setTableSorted: () => true,
            },
        ],
    })),
    selectors({
        response: [
            (s) => [s.query, s.rawResponse],
            (query: VisualizationNode, response: AnyResponseType | null): AnyResponseType | null =>
                getBIVisualizationResponse(query, response),
        ],
        hasMoreData: [
            (s) => [s.response, s.rawHasMoreData],
            (response: AnyResponseType | null, rawHasMoreData: boolean): boolean =>
                !!(response && 'hasMore' in response && response.hasMore) || rawHasMoreData,
        ],
        columns: [
            (s) => [s.response],
            (
                response:
                    | Record<string, any>
                    | null
                    | import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
                    | import('~/queries/schema/schema-general').HogQLAutocompleteResponse
                    | import('~/queries/schema/schema-general').HogQLMetadataResponse
                    | import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
                    | import('~/queries/schema/schema-general').HogQueryResponse
                    | import('~/queries/schema/schema-general').LogAttributesQueryResponse
                    | import('~/queries/schema/schema-general').LogValuesQueryResponse
                    | import('~/queries/schema/schema-general').MetricsQueryResponse
                    | import('~/queries/schema/schema-general').SessionsQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansQueryResponse
            ): Column[] => columnsFromResponse(response),
            { resultEqualityCheck: objectsEqual },
        ],
        numericalColumns: [
            (s) => [s.columns],
            (columns: Column[]): Column[] => {
                return columns.filter((n) => n.type.isNumerical)
            },
        ],
        hasDateTimeColumns: [
            (s) => [s.columns],
            (columns: Column[]): boolean => columns.some((column) => ['DATE', 'DATETIME'].includes(column.type.name)),
        ],
        dashboardId: [() => [(_, props) => props.dashboardId], (dashboardId) => dashboardId ?? null],
        showEditingUI: [
            (s) => [(_, props: DataVisualizationLogicProps) => props.editMode, s.dashboardId],
            (editMode: boolean | undefined, dashboardId) => {
                if (dashboardId) {
                    return false
                }
                return !!editMode
            },
        ],
        showResultControls: [
            (s) => [(_, props: DataVisualizationLogicProps) => props.editMode, s.dashboardId],
            (editMode: boolean | undefined, dashboardId) => {
                if (editMode) {
                    return true
                }

                return !dashboardId
            },
        ],
        presetChartHeight: [
            (s, props) => [props.key, s.dashboardId, s.activeSceneId],
            (key: string, dashboardId, activeSceneId: string | null) => {
                // Keys for SQL editor visualizations can render outside the SQLEditor scene,
                // e.g. in embedded mode, so key matching keeps sizing consistent.
                const editorVisualization =
                    activeSceneId === Scene.BusinessIntelligence ||
                    activeSceneId === Scene.SQLEditor ||
                    key.includes('SQLEditor') ||
                    key.startsWith('data-warehouse-editor-data-node-')

                if (activeSceneId === Scene.Insight) {
                    return true
                }

                return !key.includes('new-SQL') && !dashboardId && !editorVisualization
            },
        ],
        sourceFeatures: [
            (_, props) => [props.query],
            (query: VisualizationNode): Set<QueryFeature> => getQueryFeatures(query.source),
        ],
        isShowingCachedResults: [
            () => [(_, props) => props.cachedResults ?? null],
            (cachedResults: AnyResponseType | null): boolean => !!cachedResults,
        ],
        isTransposed: [
            (s) => [s.query],
            (query: VisualizationNode): boolean => query.tableSettings?.transpose ?? false,
        ],
        yData: [
            (s) => [s.selectedYAxis, s.response, s.columns, s.chartSettings, s.effectiveVisualizationType, s.query],
            (
                ySeries: (SelectedYAxis | null)[] | null,
                response:
                    | Record<string, any>
                    | null
                    | import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
                    | import('~/queries/schema/schema-general').HogQLAutocompleteResponse
                    | import('~/queries/schema/schema-general').HogQLMetadataResponse
                    | import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
                    | import('~/queries/schema/schema-general').HogQueryResponse
                    | import('~/queries/schema/schema-general').LogAttributesQueryResponse
                    | import('~/queries/schema/schema-general').LogValuesQueryResponse
                    | import('~/queries/schema/schema-general').MetricsQueryResponse
                    | import('~/queries/schema/schema-general').SessionsQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansQueryResponse,
                columns: Column[],
                chartSettings: ChartSettings,
                visualizationType: ChartDisplayType,
                query: VisualizationNode
            ): AxisSeries<number | null>[] => {
                if (!response || ySeries === null || ySeries.length === 0) {
                    return [EmptyYAxisSeries]
                }

                const showNullsAsZero = chartSettings.showNullsAsZero ?? false
                const data =
                    'results' in response && Array.isArray(response.results)
                        ? response.results
                        : 'result' in response && Array.isArray(response.result)
                          ? response.result
                          : []

                const seriesRows = visualizationType === ChartDisplayType.ActionsTable ? [] : data
                const mappedSeries = visualizationType === ChartDisplayType.Metric ? ySeries.slice(0, 1) : ySeries
                const seriesData = mappedSeries
                    .map((series): AxisSeries<number | null> | null => {
                        if (!series) {
                            return EmptyYAxisSeries
                        }

                        const column = columns.find((n) => n.name === series.name)
                        if (!column) {
                            return EmptyYAxisSeries
                        }

                        return {
                            column,
                            data: seriesRows.map((n) => {
                                try {
                                    const multiplier = series.settings.formatting?.style === 'percent' ? 100 : 1

                                    const isNotANumber =
                                        Number.isNaN(n[column.dataIndex]) ||
                                        n[column.dataIndex] === undefined ||
                                        n[column.dataIndex] === null
                                    if (isNotANumber) {
                                        return showNullsAsZero ? 0 : null
                                    }

                                    // Do not round to decimalPlaces here. The chart formatters round for display,
                                    // and the metric card and pie totals must sum the raw values.
                                    const isInt = Number.isInteger(n[column.dataIndex])
                                    const parsed = isInt
                                        ? parseInt(n[column.dataIndex], 10) * multiplier
                                        : parseFloat(n[column.dataIndex]) * multiplier
                                    return Number.isNaN(parsed) ? (showNullsAsZero ? 0 : null) : parsed
                                } catch {
                                    return showNullsAsZero ? 0 : null
                                }
                            }),
                            settings: getBISeriesSettings(query, series.settings),
                        }
                    })
                    .filter((series): series is AxisSeries<number | null> => Boolean(series))

                return seriesData
            },
        ],
        xData: [
            (s) => [s.selectedXAxis, s.response, s.columns, s.query],
            (
                xSeries: string | null,
                response:
                    | Record<string, any>
                    | null
                    | import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
                    | import('~/queries/schema/schema-general').HogQLAutocompleteResponse
                    | import('~/queries/schema/schema-general').HogQLMetadataResponse
                    | import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
                    | import('~/queries/schema/schema-general').HogQueryResponse
                    | import('~/queries/schema/schema-general').LogAttributesQueryResponse
                    | import('~/queries/schema/schema-general').LogValuesQueryResponse
                    | import('~/queries/schema/schema-general').MetricsQueryResponse
                    | import('~/queries/schema/schema-general').SessionsQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansQueryResponse,
                columns: Column[],
                query: VisualizationNode
            ): AxisSeries<string> | null => {
                if (!response) {
                    return {
                        column: {
                            name: 'None',
                            type: {
                                name: 'STRING',
                                isNumerical: false,
                            },
                            label: 'None',
                            dataIndex: -1,
                        },
                        data: [],
                    }
                }

                const data =
                    ('results' in response ? response.results : 'result' in response ? response.result : null) ?? []

                if (xSeries === null) {
                    return {
                        column: {
                            name: 'None',
                            type: {
                                name: 'STRING',
                                isNumerical: false,
                            },
                            label: 'None',
                            dataIndex: -1,
                        },
                        data: data.map(() => ''),
                    }
                }

                const column = columns.find((n) => n.name === xSeries)
                if (!column) {
                    return null
                }

                return {
                    column,
                    data: data.map((n: any) =>
                        query.kind === NodeKind.BIVisualizationNode
                            ? n[column.dataIndex]
                            : humanizeEventColumnValue(column.name, n[column.dataIndex])
                    ),
                }
            },
        ],
        sourceTabularColumns: [
            (s) => [s.tabularColumnSettings, s.response, s.columns],
            (
                tabularColumnSettings: (SelectedYAxis | null)[] | null,
                response:
                    | Record<string, any>
                    | null
                    | import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
                    | import('~/queries/schema/schema-general').HogQLAutocompleteResponse
                    | import('~/queries/schema/schema-general').HogQLMetadataResponse
                    | import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
                    | import('~/queries/schema/schema-general').HogQueryResponse
                    | import('~/queries/schema/schema-general').LogAttributesQueryResponse
                    | import('~/queries/schema/schema-general').LogValuesQueryResponse
                    | import('~/queries/schema/schema-general').MetricsQueryResponse
                    | import('~/queries/schema/schema-general').SessionsQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansQueryResponse,
                columns: Column[]
            ): AxisSeries<any>[] => {
                if (!response) {
                    return []
                }

                return columns.map((col) => {
                    const series = (tabularColumnSettings || []).find((n) => n?.name === col.name)

                    return {
                        column: col,
                        data: [],
                        settings: series?.settings ?? DefaultAxisSettings(),
                    }
                })
            },
        ],
        tableResults: [
            (s) => [s.response],
            (response: AnyResponseType | null): HogQLQueryResponse['results'] => {
                if (response && 'results' in response && Array.isArray(response.results)) {
                    return response.results
                }
                if (response && 'result' in response && Array.isArray(response.result)) {
                    return response.result
                }
                return []
            },
        ],
        getSourceTableCell: [
            (s) => [s.sourceTabularColumns, s.tableResults, s.chartSettings, s.query],
            (
                sourceTabularColumns: AxisSeries<any>[],
                data: HogQLQueryResponse['results'],
                chartSettings: ChartSettings,
                query: VisualizationNode
            ): ((rowIndex: number, columnIndex: number) => TableDataCell<any>) => {
                const showNullsAsZero = chartSettings.showNullsAsZero ?? false
                const dimensions = new Map(
                    query.kind === NodeKind.BIVisualizationNode
                        ? getBIResultDimensions(query.config).map(({ column, field }) => [column, field])
                        : []
                )
                const memberDisplay =
                    query.kind === NodeKind.BIVisualizationNode ? createBIMemberDisplayLookup(query.config) : undefined

                return (rowIndex, columnIndex): TableDataCell<any> => {
                    const column = sourceTabularColumns[columnIndex]
                    if (!column) {
                        return {
                            value: null,
                            formattedValue: null,
                            type: 'STRING',
                        }
                    }

                    const value = data[rowIndex][column.column.dataIndex]
                    const dimension = dimensions.get(column.column.name)
                    const alias = dimension ? memberDisplay?.(dimension, value) : undefined
                    if (alias !== undefined) {
                        return { value, formattedValue: alias, type: column.column.type.name }
                    }

                    if (column.column.type.isNumerical) {
                        try {
                            if (value === null) {
                                const nullReplacement = showNullsAsZero ? 0 : null

                                return {
                                    value: nullReplacement,
                                    formattedValue: formatDataWithSettings(nullReplacement, column.settings),
                                    type: column.column.type.name,
                                }
                            }

                            const multiplier = column.settings?.formatting?.style === 'percent' ? 100 : 1

                            if (
                                column.settings?.formatting?.decimalPlaces != null &&
                                column.settings.formatting.style !== 'short'
                            ) {
                                return {
                                    value,
                                    formattedValue: formatDataWithSettings(
                                        parseFloat(
                                            (parseFloat(value.toString()) * multiplier).toFixed(
                                                column.settings.formatting.decimalPlaces
                                            )
                                        ),
                                        column.settings
                                    ),
                                    type: column.column.type.name,
                                }
                            }

                            const isInt = Number.isInteger(value)
                            return {
                                value,
                                formattedValue: formatDataWithSettings(
                                    isInt
                                        ? parseInt(value.toString(), 10) * multiplier
                                        : parseFloat(value.toString()) * multiplier,
                                    column.settings
                                ),
                                type: column.column.type.name,
                            }
                        } catch {
                            return {
                                value: 0,
                                formattedValue: '0',
                                type: column.column.type.name,
                            }
                        }
                    }

                    return {
                        value: convertTableValue(value, column.column.type.name),
                        formattedValue: formatDataWithSettings(value, column.settings),
                        type: column.column.type.name,
                    }
                }
            },
        ],
        tabularColumns: [
            (s) => [s.sourceTabularColumns, s.tableResults, s.isTransposed],
            (
                sourceTabularColumns: AxisSeries<any>[],
                tableResults: HogQLQueryResponse['results'],
                isTransposed: boolean
            ): AxisSeries<any>[] => {
                if (!isTransposed) {
                    return sourceTabularColumns
                }

                if (sourceTabularColumns.length === 0) {
                    return []
                }

                return [
                    {
                        column: {
                            name: TRANSPOSED_FIELD_COLUMN_NAME,
                            type: {
                                name: 'STRING',
                                isNumerical: false,
                            },
                            label: 'Field',
                            dataIndex: -1,
                        },
                        data: [],
                        settings: {
                            ...DefaultAxisSettings(),
                            display: {
                                label: 'Field',
                            },
                        },
                    },
                    ...Array.from(
                        { length: tableResults.length },
                        (_, index): AxisSeries<any> => ({
                            column: {
                                name: `${TRANSPOSED_ROW_COLUMN_PREFIX}${index}`,
                                type: {
                                    name: 'STRING',
                                    isNumerical: false,
                                },
                                label: `Row ${index + 1}`,
                                dataIndex: -1,
                            },
                            data: [],
                            settings: {
                                ...DefaultAxisSettings(),
                                display: {
                                    label: `Row ${index + 1}`,
                                },
                            },
                        })
                    ),
                ]
            },
        ],
        tableRows: [
            (s) => [s.tableResults, s.sourceTabularColumns, s.isTransposed],
            (results: HogQLQueryResponse['results'], columns: AxisSeries<any>[], isTransposed: boolean): TableRow[] => {
                if (results.length === 0) {
                    return []
                }
                return Array.from({ length: isTransposed ? columns.length : results.length }, (_, rowIndex) => ({
                    rowIndex,
                }))
            },
        ],
        getTableCell: [
            (s) => [s.getSourceTableCell, s.sourceTabularColumns, s.isTransposed],
            (
                getSourceTableCell: (rowIndex: number, columnIndex: number) => TableDataCell<any>,
                columns: AxisSeries<any>[],
                isTransposed: boolean
            ): ((rowIndex: number, columnIndex: number) => TableDataCell<any>) =>
                (rowIndex, columnIndex): TableDataCell<any> => {
                    if (!isTransposed) {
                        return getSourceTableCell(rowIndex, columnIndex)
                    }
                    const sourceColumnName = columns[rowIndex].column.name
                    if (columnIndex === 0) {
                        return {
                            value: sourceColumnName,
                            formattedValue: null,
                            type: 'STRING',
                            sourceColumnName,
                            isTransposedHeader: true,
                        }
                    }
                    return { ...getSourceTableCell(columnIndex - 1, rowIndex), sourceColumnName }
                },
        ],
        dataVisualizationProps: [() => [(_, props) => props], (props): DataVisualizationLogicProps => props],
        effectiveVisualizationType: [
            (s) => [s.visualizationType, s.autoVisualizationType],
            (visualizationType: ChartDisplayType, autoVisualizationType: ChartDisplayType): ChartDisplayType =>
                visualizationType === ChartDisplayType.Auto ? autoVisualizationType : visualizationType,
        ],
        autoVisualizationType: [
            (s) => [s.columns, s.response, s.query],
            (
                columns: Column[],
                response:
                    | Record<string, any>
                    | null
                    | import('~/queries/schema/schema-general').ErrorTrackingQueryResponse
                    | import('~/queries/schema/schema-general').HogQLAutocompleteResponse
                    | import('~/queries/schema/schema-general').HogQLMetadataResponse
                    | import('~/queries/schema/schema-general').HogQLQueryResponse<any[]>
                    | import('~/queries/schema/schema-general').HogQueryResponse
                    | import('~/queries/schema/schema-general').LogAttributesQueryResponse
                    | import('~/queries/schema/schema-general').LogValuesQueryResponse
                    | import('~/queries/schema/schema-general').MetricsQueryResponse
                    | import('~/queries/schema/schema-general').SessionsQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAggregationQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansAttributeBreakdownQueryResponse
                    | import('~/queries/schema/schema-general').TraceSpansQueryResponse,
                query: VisualizationNode
            ): ChartDisplayType =>
                query.kind === NodeKind.BIVisualizationNode
                    ? getBIAutoChartType(query.config)
                    : getAutoVisualizationType(columns, rowCountFromResponse(response)),
        ],
        // The Hog VM and its crypto polyfills are large, so only a table that shows formatting rules loads them.
        // Auto resolves to a table until columns arrive, so it waits for them before it decides.
        needsHogVm: [
            (s) => [
                s.visualizationType,
                s.effectiveVisualizationType,
                s.columns,
                s.conditionalFormattingRules,
                s.query,
            ],
            (
                visualizationType: ChartDisplayType,
                effectiveVisualizationType: ChartDisplayType,
                columns: Column[],
                rules: ConditionalFormattingRule[],
                query: VisualizationNode
            ): boolean =>
                (visualizationType !== ChartDisplayType.Auto || columns.length > 0) &&
                (effectiveVisualizationType === ChartDisplayType.ActionsTable ||
                    (query.kind === NodeKind.BIVisualizationNode && isBIPivotTable(query.config))) &&
                rules.length > 0,
        ],
        hogVmLoadFailed: [
            (s) => [s.needsHogVm, s.hogVmLoadError],
            (needsHogVm: boolean, hogVmLoadError: unknown): boolean => needsHogVm && !!hogVmLoadError,
        ],
        isTableVisualization: [
            (s) => [s.effectiveVisualizationType],
            (visualizationType: ChartDisplayType): boolean =>
                // BoldNumber relies on yAxis formatting so it's considered a table visualization
                visualizationType === ChartDisplayType.ActionsTable ||
                visualizationType === ChartDisplayType.BoldNumber,
        ],
        showTableSettings: [
            (s) => [s.effectiveVisualizationType],
            (visualizationType: ChartDisplayType): boolean =>
                visualizationType === ChartDisplayType.ActionsTable ||
                visualizationType === ChartDisplayType.BoldNumber,
        ],
        isColumnPinned: [
            (s) => [s.pinnedColumns],
            (pinnedColumns: string[]) =>
                (columnName: string): boolean => {
                    return pinnedColumns.includes(columnName)
                },
        ],
        isPinningEnabled: [
            (s) => [s.activeSceneId, s.isTransposed],
            (activeSceneId: Scene | null, isTransposed: boolean): boolean => {
                // disable column pinning in sql editor or when transposed
                return activeSceneId !== Scene.SQLEditor && !isTransposed
            },
        ],
    }),
    sharedListeners(({ values, actions }) => ({
        axesChanged: () => {
            const yColumns =
                values.selectedYAxis?.filter((n: SelectedYAxis | null): n is SelectedYAxis => Boolean(n)) ?? []
            const xColumn: ChartAxis | undefined =
                values.selectedXAxis !== null ? { column: values.selectedXAxis } : undefined
            const columns =
                values.tabularColumnSettings?.filter((n: SelectedYAxis | null): n is SelectedYAxis => Boolean(n)) ?? []

            actions.setQuery((query) => ({
                ...query,
                chartSettings: {
                    ...query.chartSettings,
                    yAxis: yColumns.map((n) => ({ column: n.name, settings: cloneSettings(n.settings) })),
                    xAxis: xColumn,
                },
                tableSettings: {
                    ...query.tableSettings,
                    columns: columns.map((n) => ({ column: n.name, settings: cloneSettings(n.settings) })),
                },
            }))
        },
        conditionalFormattingRules: () => {
            const rules = values.conditionalFormattingRules
            const saveableRules = rules.filter((n) => n.columnName && n.input && n.templateId && n.bytecode.length)

            if (values.query.kind === NodeKind.BIVisualizationNode) {
                captureBIWorksheetAction('conditional_formatting_updated', values.query.config, {
                    rule_count: saveableRules.length,
                })
            }

            actions.setQuery((query) => ({
                ...query,
                tableSettings: {
                    ...query.tableSettings,
                    conditionalFormatting: saveableRules,
                },
            }))
        },
        pinnedColumnsChanged: () => {
            actions.setQuery((query) => ({
                ...query,
                tableSettings: {
                    ...query.tableSettings,
                    pinnedColumns: values.pinnedColumns,
                },
            }))
        },
    })),
    listeners(({ props, values, actions, sharedListeners }) => ({
        setSideBarTab: ({ tab }) => {
            if (tab === SideBarTab.ConditionalFormatting && values.query.kind === NodeKind.BIVisualizationNode) {
                captureBIWorksheetAction('conditional_formatting_opened', values.query.config)
            }
        },
        loadHogVm: async () => {
            try {
                actions.setHogVm(await retryImport(() => import('lib/hog')))
            } catch (error) {
                // A chunk that fails to load is a network or stale-deploy problem, not a bug to report.
                if (!isChunkLoadError(error)) {
                    posthog.captureException(error)
                }
                actions.setHogVmLoadError(error)
            }
        },
        updateChartSettings: ({ settings }) => {
            if (values.query.kind === NodeKind.BIVisualizationNode) {
                captureBIWorksheetAction('chart_settings_changed', values.query.config, {
                    setting_keys: Object.keys(settings),
                })
            }
            actions.setQuery((query) => ({
                ...query,
                chartSettings: mergeChartSettings(query.chartSettings ?? ({} as ChartSettings), settings),
            }))
        },
        setQuery: ({ setter }) => {
            if (props.setQuery) {
                props.setQuery(setter)
            }
        },
        setVisualizationType: ({ node }) => {
            props.setQuery?.(() => node)
        },
        setTransposeResults: ({ transpose }) => {
            posthog.capture('sql table transposed', { transpose, query_kind: values.query.kind })
            actions.setQuery((query) => ({
                ...query,
                tableSettings: {
                    ...query.tableSettings,
                    transpose,
                },
            }))
        },
        toggleChartSettingsPanel: ({ open }) => {
            const shouldOpen = open ?? !values.isChartSettingsPanelOpen
            if (!shouldOpen) {
                return
            }

            if (values.visualizationType !== ChartDisplayType.TwoDimensionalHeatmap) {
                return
            }

            applyAutoHeatmapSettings(actions, values.columns, values.chartSettings.heatmap ?? {})
        },
        // Plain tables do not mount seriesBreakdownLogic, so the breakdown resets here.
        clearAxis: [
            () =>
                actions.setQuery((query) => ({
                    ...query,
                    chartSettings: { ...query.chartSettings, seriesBreakdownColumn: undefined },
                })),
            sharedListeners.axesChanged,
        ],
        updateXSeries: [sharedListeners.axesChanged],
        addYSeries: [sharedListeners.axesChanged],
        initializeAxes: [sharedListeners.axesChanged],
        updateSeriesIndex: [sharedListeners.axesChanged],
        updateSeries: [sharedListeners.axesChanged],
        deleteYSeries: [sharedListeners.axesChanged],
        updateConditionalFormattingRule: [sharedListeners.conditionalFormattingRules],
        toggleColumnPin: [
            ({ columnName }) => {
                posthog.capture('sql table column pin toggled', {
                    pinned: values.isColumnPinned(columnName),
                    query_kind: values.query.kind,
                })
            },
            sharedListeners.pinnedColumnsChanged,
        ],
    })),
    subscriptions(({ actions, values }) => ({
        needsHogVm: (needsHogVm: boolean) => {
            if (needsHogVm && !values.hogVm) {
                actions.loadHogVm()
            }
        },
        columns: (value: Column[], oldValue: Column[]) => {
            // If the response is cleared, then don't update any internal values
            if (!values.response || (!(values.response as any).results && !(values.response as any).result)) {
                return
            }

            // When query columns update, clear all internal values and re-setup tabular columns and chart series

            const oldTabularColumnSettings: (SelectedYAxis | null)[] | null = JSON.parse(
                JSON.stringify(values.tabularColumnSettings)
            )

            const currentColumnNames = new Set(value.map((column) => column.name))
            const hasInvalidSelectedXAxis =
                values.selectedXAxis !== null && !currentColumnNames.has(values.selectedXAxis)
            const hasInvalidSelectedYAxis =
                values.selectedYAxis?.some((series) => {
                    if (series === null) {
                        return false
                    }

                    const column = value.find((nextColumn) => nextColumn.name === series.name)
                    return !column || !column.type.isNumerical
                }) ?? false

            if (hasInvalidSelectedXAxis || hasInvalidSelectedYAxis) {
                actions.clearAxis()
            } else if (oldValue && oldValue.length) {
                if (JSON.stringify(value) !== JSON.stringify(oldValue)) {
                    actions.clearAxis()
                }
            }

            // One action, not one per column, because each dispatch runs the reducers of every mounted logic.
            const toAxis = (name: string): SelectedYAxis => ({
                name,
                settings: oldTabularColumnSettings?.find((n) => n?.name === name)?.settings ?? DefaultAxisSettings(),
            })
            const tabularColumns =
                values.response && values.tabularColumnSettings === null
                    ? value.map((column) => toAxis(column.name))
                    : null
            const defaultAxes =
                values.response && values.selectedXAxis === null && values.selectedYAxis === null
                    ? deriveDefaultAxes(value)
                    : null
            const yAxis = defaultAxes?.yAxis.length ? defaultAxes.yAxis.map(toAxis) : null
            const xAxis = defaultAxes?.xAxis ?? null
            if (tabularColumns?.length || yAxis || xAxis) {
                actions.initializeAxes(tabularColumns?.length ? tabularColumns : null, yAxis, xAxis)
            }

            if (values.effectiveVisualizationType === ChartDisplayType.TwoDimensionalHeatmap) {
                applyAutoHeatmapSettings(actions, value, values.chartSettings.heatmap ?? {})
            }

            if (values.effectiveVisualizationType === ChartDisplayType.BoxPlot) {
                actions.updateChartSettings({
                    boxPlot: getAutoBoxPlotSettings(value, values.chartSettings.boxPlot),
                })
            }

            // The generic setup above only lands a numeric x for a scatter by luck (a DATE column or a
            // non-numeric first column). Resolve it explicitly so an all-numeric query, a column change,
            // or a persisted/assistant-created scatter still gets a plottable x axis.
            if (values.effectiveVisualizationType === ChartDisplayType.ScatterPlot) {
                applyScatterXAxis(actions, value, values.selectedXAxis, values.selectedYAxis)
            }
        },
    })),
])