: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import { MakeLogicType, actions, kea, key, listeners, path, props, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
import { encodeParams } from 'kea-router'
import { subscriptions } from 'kea-subscriptions'
import { windowValues } from 'kea-window-values'
import {
CommonFilters,
HeatmapArea,
HeatmapBoundsFilter,
HeatmapEventsResponse,
HeatmapFilters,
HeatmapFixedPositionMode,
HeatmapJsData,
HeatmapJsDataPoint,
HeatmapKind,
} from 'lib/components/heatmaps/types'
import {
DEFAULT_HEATMAP_FILTERS,
DEFAULT_HEATMAP_HEIGHT,
DEFAULT_HEATMAP_WIDTH,
calculateViewportRange,
} from 'lib/components/IframedToolbarBrowser/utils'
import { LemonSelectOption } from 'lib/lemon-ui/LemonSelect'
import { lemonToast } from 'lib/lemon-ui/LemonToast/LemonToast'
import { dateFilterToText } from 'lib/utils/dateFilters'
import { getAppContext } from 'lib/utils/getAppContext'
import { toolbarConfigLogic } from '~/toolbar/shared/toolbarConfigLogic'
import { toolbarFetch } from '~/toolbar/shared/toolbarFetch'
import { ToolbarRequestError } from '~/toolbar/shared/toolbarRequestError'
import { HeatmapElement, HeatmapResponseType } from '~/toolbar/shared/types'
import { FilterType } from '~/types'
export interface HeatmapDateRangeOverride {
date_from: string
date_to: string
timestamp_from: string
timestamp_to: string
}
export interface HeatmapHistoryView {
owner: string
dateRange: HeatmapDateRangeOverride
width: number
imageUrl: string
}
// The endpoint defaults to a bounded page for API callers; the overlay renders every point.
const UNBOUNDED_HEATMAP_LIMIT = 0
// Limit canvas height to prevent browser freezing with heatmap.js
// Large canvases (e.g., 24000px) cause heatmap.js to block the main thread
export const MAX_HEATMAP_HEIGHT = 8000
export const HEATMAP_LOADING_DEBOUNCE_MS = 200
export const HEATMAP_TYPES: Record<HeatmapKind, { label: string; noun: string }> = {
click: { label: 'Clicks', noun: 'click' },
rageclick: { label: 'Rageclicks', noun: 'rageclick' },
deadclick: { label: 'Dead clicks', noun: 'dead click' },
mousemove: { label: 'Mouse moves', noun: 'mouse move' },
scrolldepth: { label: 'Scroll depth', noun: 'scroll depth' },
}
export const HEATMAP_TYPE_OPTIONS: LemonSelectOption<HeatmapKind>[] = (Object.keys(HEATMAP_TYPES) as HeatmapKind[]).map(
(value) => ({ value, label: HEATMAP_TYPES[value].label })
)
export const HEATMAP_COLOR_PALETTE_OPTIONS: LemonSelectOption<string>[] = [
{ value: 'default', label: 'Default (multicolor)' },
{ value: 'red', label: 'Red (monocolor)' },
{ value: 'green', label: 'Green (monocolor)' },
{ value: 'blue', label: 'Blue (monocolor)' },
]
async function parseHeatmapErrorMessage(response: Response): Promise<string> {
try {
const body = await response.clone().json()
if (typeof body?.detail === 'string' && body.detail.length > 0) {
return body.detail
}
for (const value of Object.values(body ?? {})) {
if (Array.isArray(value) && typeof value[0] === 'string') {
return value[0]
}
if (typeof value === 'string' && value.length > 0) {
return value
}
}
} catch {
/* empty */
}
return `Heatmap request failed (status ${response.status})`
}
export interface HeatmapDataLogicProps {
context: 'in-app' | 'toolbar'
exportToken?: string | null
}
/**
* Fetch a heatmap endpoint and raise request failures the right way for each context:
* in the toolbar a failed request is an expected outcome, so it becomes a tagged
* `ToolbarRequestError` (drives the loader's *Failure action without being reported to
* error tracking); in-app the pre-existing plain-error behavior is preserved.
*/
async function fetchHeatmapData(
props: HeatmapDataLogicProps,
apiURL: string,
options: { authenticateOn403?: boolean } = {}
): Promise<Response> {
let response: Response
try {
response = await (props.context === 'toolbar'
? toolbarFetch(apiURL, 'GET')
: props.exportToken
? fetch(apiURL, { headers: { Authorization: `Bearer ${props.exportToken}` } })
: fetch(apiURL))
} catch (e) {
if (props.context === 'toolbar') {
throw new ToolbarRequestError('Network error while loading heatmap data')
}
throw e
}
if (props.context === 'toolbar' && response.status === 403 && options.authenticateOn403) {
toolbarConfigLogic.actions.authenticate()
}
if (response.status !== 200) {
const message = await parseHeatmapErrorMessage(response)
if (props.context === 'toolbar') {
throw new ToolbarRequestError(message, response.status)
}
throw new Error(message)
}
return response
}
export function heatmapApiPath(context: HeatmapDataLogicProps['context'], endpoint: '' | 'events/'): string {
if (context === 'in-app') {
// The unscoped /api/heatmap/ route resolves the team from the user's *global* current
// project, which any other tab can change, so pin the team this page was loaded for
// instead. The app context team is also set on export renders (team_for_public_context).
const teamId = getAppContext()?.current_team?.id
if (teamId != null) {
return `/api/projects/${teamId}/heatmaps/${endpoint}`
}
}
return `/api/heatmap/${endpoint}`
}
// A row added but not yet pointed at an event carries a null id. It selects nothing, and the API rejects
// it, so leave those out of the request instead of failing the whole heatmap over a half-filled row.
export function eventFilterParam(events: CommonFilters['events']): string | undefined {
const selected = events?.filter((event) => !!event.id)
return selected?.length ? JSON.stringify(selected) : undefined
}
export type HrefMatchType = 'exact' | 'pattern'
export function isWithinBounds(
point: { x: number; y: number; targetFixed: boolean },
boundsFilter: HeatmapBoundsFilter | null
): boolean {
if (!boundsFilter) {
return true
}
// points and areas live in different coordinate spaces depending on fixedness, so a
// point of the other kind can't be meaningfully tested against this area — exclude it
if (point.targetFixed !== boundsFilter.areaFixed) {
return false
}
const { bounds } = boundsFilter
return point.x >= bounds.left && point.x <= bounds.right && point.y >= bounds.top && point.y <= bounds.bottom
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface heatmapDataLogicValues {
analysisWidth: number
areaEvents: HeatmapEventsResponse | null
areaEventsLoading: boolean
areaEventsLoadingMore: boolean
commonFilters: CommonFilters
dateRange: string | null
dateRangeOverride: HeatmapDateRangeOverride | null
effectiveCommonFilters: CommonFilters
filteredHeatmapElements: HeatmapElement[]
heatmapBoundsFilter: HeatmapBoundsFilter | null
heatmapColorPalette: string | null
heatmapElements: HeatmapElement[]
heatmapEmpty: boolean
heatmapFilters: HeatmapFilters
heatmapFixedPositionMode: HeatmapFixedPositionMode
heatmapJsData: HeatmapJsData
heatmapTooltipNoun: string
heatmapTooltipSuppressed: boolean
heightOverride: number
historyView: HeatmapHistoryView | null
href: string | null
hrefMatchType: HrefMatchType
isHeightCapped: boolean
isReady: boolean
maxYFromEvents: number
rawHeatmap: HeatmapResponseType | null
rawHeatmapLoading: boolean
selectedArea: HeatmapArea | null
showEventsPanel: boolean
viewportRange: {
max: number
min: number
}
widthOverride: number
windowHeight: number
windowWidth: number
windowWidthOverride: number | null
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface heatmapDataLogicActions {
clearSelectedArea: () => {
value: true
}
loadAreaEvents: (_: any) => any
loadAreaEventsFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
loadAreaEventsSuccess: (
areaEvents: HeatmapEventsResponse | null,
payload?: any
) => {
areaEvents: HeatmapEventsResponse | null
payload?: any
}
loadHeatmap: () => {
value: true
}
loadHeatmapFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
loadHeatmapSuccess: (
rawHeatmap: HeatmapResponseType | null,
payload?: {
value: true
}
) => {
rawHeatmap: HeatmapResponseType | null
payload?: {
value: true
}
}
loadMoreAreaEvents: () => {
value: true
}
loadMoreAreaEventsSuccess: (payload: HeatmapEventsResponse) => {
payload: HeatmapEventsResponse
}
patchHeatmapFilters: (filters: Partial<HeatmapFilters>) => {
filters: Partial<HeatmapFilters>
}
resetHeatmapData: () => any
resetHeatmapDataFailure: (
error: string,
errorObject?: any
) => {
error: string
errorObject?: any
}
resetHeatmapDataSuccess: (
rawHeatmap: {
results: never[]
},
payload?: any
) => {
rawHeatmap: {
results: never[]
}
payload?: any
}
setCommonFilters: (filters: CommonFilters) => {
filters: CommonFilters
}
setHeatmapBoundsFilter: (boundsFilter: HeatmapBoundsFilter | null) => {
boundsFilter: HeatmapBoundsFilter | null
}
setHeatmapColorPalette: (palette: string | null) => {
palette: string | null
}
setHeatmapFilters: (filters: HeatmapFilters) => {
filters: HeatmapFilters
}
setHeatmapFixedPositionMode: (mode: HeatmapFixedPositionMode) => {
mode: HeatmapFixedPositionMode
}
setHeatmapTooltipSuppressed: (suppressed: boolean) => {
suppressed: boolean
}
setHistoryView: (view: HeatmapHistoryView | null) => {
view: HeatmapHistoryView | null
}
setHref: (href: string) => {
href: string
}
setHrefMatchType: (matchType: HrefMatchType) => {
matchType: HrefMatchType
}
setIsReady: (isReady: boolean) => {
isReady: boolean
}
setSelectedArea: (area: HeatmapArea | null) => {
area: HeatmapArea | null
}
setShowEventsPanel: (show: boolean) => {
show: boolean
}
setWindowWidthOverride: (widthOverride: number | null) => {
widthOverride: number | null
}
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface heatmapDataLogicMeta {
key: 'in-app' | 'toolbar'
__keaTypeGenInternalSelectorTypes: {
dateRangeOverride: (historyView: HeatmapHistoryView | null) => HeatmapDateRangeOverride | null
effectiveCommonFilters: (
commonFilters: CommonFilters,
dateRangeOverride: HeatmapDateRangeOverride | null
) => CommonFilters
dateRange: (commonFilters: CommonFilters) => string | null
heatmapElements: (rawHeatmap: HeatmapResponseType | null) => HeatmapElement[]
analysisWidth: (
windowWidthOverride: number | null,
windowWidth: number,
historyView: HeatmapHistoryView | null
) => number
viewportRange: (
heatmapFilters: HeatmapFilters,
analysisWidth: number
) => {
max: number
min: number
}
widthOverride: (analysisWidth: number) => number
heatmapTooltipNoun: (heatmapFilters: HeatmapFilters) => string
heatmapEmpty: (rawHeatmap: HeatmapResponseType | null, rawHeatmapLoading: boolean) => boolean
maxYFromEvents: (heatmapElements: HeatmapElement[]) => number
heightOverride: (maxYFromEvents: number, windowHeight: number) => number
isHeightCapped: (maxYFromEvents: number) => boolean
filteredHeatmapElements: (
heatmapElements: HeatmapElement[],
analysisWidth: number,
heatmapBoundsFilter: HeatmapBoundsFilter | null
) => HeatmapElement[]
heatmapJsData: (
filteredHeatmapElements: HeatmapElement[],
analysisWidth: number,
heatmapFixedPositionMode: HeatmapFixedPositionMode
) => HeatmapJsData
}
}
export type heatmapDataLogicType = MakeLogicType<
heatmapDataLogicValues,
heatmapDataLogicActions,
HeatmapDataLogicProps,
heatmapDataLogicMeta
>
export const heatmapDataLogic = kea<heatmapDataLogicType>([
path((key) => ['lib', 'components', 'heatmap', 'heatmapDataLogic', key]),
props({ context: 'toolbar', exportToken: null } as HeatmapDataLogicProps),
key((props) => props.context),
actions({
loadHeatmap: true,
setCommonFilters: (filters: CommonFilters) => ({ filters }),
setHistoryView: (view: HeatmapHistoryView | null) => ({ view }),
setHeatmapFilters: (filters: HeatmapFilters) => ({ filters }),
patchHeatmapFilters: (filters: Partial<HeatmapFilters>) => ({ filters }),
setHeatmapFixedPositionMode: (mode: HeatmapFixedPositionMode) => ({ mode }),
setHeatmapColorPalette: (palette: string | null) => ({ palette }),
setHeatmapTooltipSuppressed: (suppressed: boolean) => ({ suppressed }),
setHref: (href: string) => ({ href }),
setHrefMatchType: (matchType: HrefMatchType) => ({ matchType }),
setWindowWidthOverride: (widthOverride: number | null) => ({ widthOverride }),
setHeatmapBoundsFilter: (boundsFilter: HeatmapBoundsFilter | null) => ({ boundsFilter }),
setIsReady: (isReady: boolean) => ({ isReady }),
// Click-to-view-events actions
setSelectedArea: (area: HeatmapArea | null) => ({ area }),
clearSelectedArea: true,
setShowEventsPanel: (show: boolean) => ({ show }),
loadMoreAreaEvents: true,
loadMoreAreaEventsSuccess: (payload: HeatmapEventsResponse) => ({ payload }),
}),
windowValues(() => ({
windowWidth: (window: Window) => window.innerWidth,
windowHeight: (window: Window) => window.innerHeight,
})),
reducers({
hrefMatchType: [
'exact' as HrefMatchType,
{
setHrefMatchType: (_, { matchType }) => matchType,
},
],
commonFilters: [
{ date_from: '-7d' } as CommonFilters,
{ persist: true },
{
setCommonFilters: (_, { filters }) => filters,
},
],
historyView: [null as HeatmapHistoryView | null, { setHistoryView: (_, { view }) => view }],
heatmapFilters: [
DEFAULT_HEATMAP_FILTERS,
{ persist: true },
{
setHeatmapFilters: (_, { filters }) => filters,
patchHeatmapFilters: (state, { filters }) => ({ ...state, ...filters }),
},
],
heatmapFixedPositionMode: [
'fixed' as HeatmapFixedPositionMode,
{ persist: true },
{
setHeatmapFixedPositionMode: (_, { mode }) => mode,
},
],
heatmapColorPalette: [
'default' as string | null,
{ persist: true },
{
setHeatmapColorPalette: (_, { palette }) => palette,
},
],
// e.g. while the clickmap overlay shows its own element tooltip
heatmapTooltipSuppressed: [
false,
{
setHeatmapTooltipSuppressed: (_, { suppressed }) => suppressed,
},
],
href: [
null as string | null,
{
setHref: (_, { href }) => {
return href
},
},
],
windowWidthOverride: [
null as number | null,
{ persist: true },
{
setWindowWidthOverride: (_, { widthOverride }) => widthOverride,
},
],
// deliberately not persisted: the bounds describe an element on the page currently
// being viewed, so they'd be meaningless (and misleading) on the next page
heatmapBoundsFilter: [
null as HeatmapBoundsFilter | null,
{
setHeatmapBoundsFilter: (_, { boundsFilter }) => boundsFilter,
},
],
isReady: [
false as boolean,
{
setIsReady: (_, { isReady }) => isReady,
loadHeatmapSuccess: (state, { rawHeatmap }) => (rawHeatmap ? true : state),
loadHeatmapFailure: () => true,
},
],
selectedArea: [
null as HeatmapArea | null,
{
setSelectedArea: (_, { area }) => area,
clearSelectedArea: () => null,
},
],
showEventsPanel: [
false as boolean,
{
setShowEventsPanel: (_, { show }) => show,
clearSelectedArea: () => false,
},
],
areaEventsLoadingMore: [
false as boolean,
{
loadMoreAreaEvents: () => true,
loadMoreAreaEventsSuccess: () => false,
},
],
// Additional reducers for areaEvents (loader is defined below)
areaEvents: [
null as HeatmapEventsResponse | null,
{
loadMoreAreaEventsSuccess: (_, { payload }) => payload,
clearSelectedArea: () => null,
},
],
}),
loaders(({ values, props, actions }) => ({
rawHeatmap: [
null as HeatmapResponseType | null,
{
resetHeatmapData: () => ({ results: [] }),
loadHeatmap: async (_, breakpoint) => {
await breakpoint(150)
if (!values.href || !values.href.trim().length) {
return null
}
if (!values.heatmapFilters.enabled) {
return null
}
actions.setIsReady(false)
const { date_from, date_to, filter_test_accounts, cohort_ids, events } =
values.effectiveCommonFilters
const { type, aggregation } = values.heatmapFilters
// toolbar fetch collapses queryparams but this URL has multiple with the same name
const apiURL = `${heatmapApiPath(props.context, '')}${encodeParams(
{
type,
date_from,
date_to,
timestamp_from: values.dateRangeOverride?.timestamp_from,
timestamp_to: values.dateRangeOverride?.timestamp_to,
url_exact: values.hrefMatchType === 'exact' ? values.href : undefined,
url_pattern: values.hrefMatchType === 'pattern' ? values.href : undefined,
viewport_width_min: values.viewportRange.min,
viewport_width_max: values.viewportRange.max,
aggregation,
filter_test_accounts,
cohort_ids: cohort_ids && cohort_ids.length > 0 ? JSON.stringify(cohort_ids) : undefined,
events: eventFilterParam(events),
limit: UNBOUNDED_HEATMAP_LIMIT,
},
'?'
)}`
// if we export the heatmap, we need to add the export token to the headers
const response = await fetchHeatmapData(props, apiURL, { authenticateOn403: true })
breakpoint()
const data = await response.json()
return data
},
},
],
areaEvents: [
null as HeatmapEventsResponse | null,
{
loadAreaEvents: async (_, breakpoint) => {
const area = values.selectedArea
if (!area || !values.href) {
return null
}
await breakpoint(100)
const { date_from, date_to, filter_test_accounts, cohort_ids, events } =
values.effectiveCommonFilters
const { type } = values.heatmapFilters
const apiURL = `${heatmapApiPath(props.context, 'events/')}${encodeParams(
{
type,
date_from,
date_to,
timestamp_from: values.dateRangeOverride?.timestamp_from,
timestamp_to: values.dateRangeOverride?.timestamp_to,
url_exact: values.hrefMatchType === 'exact' ? values.href : undefined,
url_pattern: values.hrefMatchType === 'pattern' ? values.href : undefined,
viewport_width_min: values.viewportRange.min,
viewport_width_max: values.viewportRange.max,
filter_test_accounts,
cohort_ids: cohort_ids && cohort_ids.length > 0 ? cohort_ids : undefined,
events: eventFilterParam(events),
points: JSON.stringify(area.points),
},
'?'
)}`
const response = await fetchHeatmapData(props, apiURL)
breakpoint()
return await response.json()
},
},
],
})),
selectors(({ props }) => ({
dateRangeOverride: [
(s) => [s.historyView],
(view: HeatmapHistoryView | null): HeatmapDateRangeOverride | null => view?.dateRange ?? null,
],
effectiveCommonFilters: [
(s) => [s.commonFilters, s.dateRangeOverride],
(commonFilters: CommonFilters, dateRangeOverride: HeatmapDateRangeOverride | null): CommonFilters =>
dateRangeOverride
? { ...commonFilters, date_from: dateRangeOverride.date_from, date_to: dateRangeOverride.date_to }
: commonFilters,
],
dateRange: [
(s) => [s.commonFilters],
(commonFilters: Partial<FilterType>) => {
return dateFilterToText(commonFilters.date_from, commonFilters.date_to, 'Last 7 days')
},
],
heatmapElements: [
(s) => [s.rawHeatmap],
(rawHeatmap: HeatmapResponseType | null): HeatmapElement[] => {
if (!rawHeatmap) {
return []
}
const elements: HeatmapElement[] = []
rawHeatmap?.results.forEach((element) => {
if ('scroll_depth_bucket' in element) {
elements.push({
count: element.cumulative_count,
xPercentage: 0,
targetFixed: false,
y: element.scroll_depth_bucket,
})
} else {
elements.push({
count: element.count,
xPercentage: element.pointer_relative_x,
targetFixed: element.pointer_target_fixed,
y: element.pointer_y,
})
}
})
return elements
},
],
// The viewport width this heatmap is being analyzed at. Both the rendered preview and the
// viewport filter sent to the API must read this one value, because a preview at one width
// over data collected at another places interactions where they never happened. In-app the
// preview is a fixed-width frame picked with the screen width control, so the query has to
// match that width and not the width of the analyst's own browser. In the toolbar the
// overlay sits on the real page, so the live window width is the right anchor.
analysisWidth: [
(s) => [s.windowWidthOverride, s.windowWidth, s.historyView],
(windowWidthOverride: number | null, windowWidth: number, historyView: HeatmapHistoryView | null): number =>
historyView?.width ??
windowWidthOverride ??
(props.context === 'in-app' ? DEFAULT_HEATMAP_WIDTH : windowWidth),
],
viewportRange: [
(s) => [s.heatmapFilters, s.analysisWidth],
(heatmapFilters: HeatmapFilters, analysisWidth: number) =>
calculateViewportRange(heatmapFilters, analysisWidth),
],
widthOverride: [(s) => [s.analysisWidth], (analysisWidth: number): number => analysisWidth],
heatmapTooltipNoun: [
(s) => [s.heatmapFilters],
(heatmapFilters: HeatmapFilters) => {
if (heatmapFilters.aggregation === 'unique_visitors') {
return 'visitor'
}
return (HEATMAP_TYPES[heatmapFilters.type ?? 'click'] ?? HEATMAP_TYPES.click).noun
},
],
heatmapEmpty: [
(s) => [s.rawHeatmap, s.rawHeatmapLoading],
(rawHeatmap: HeatmapResponseType | null, rawHeatmapLoading: boolean) => {
return rawHeatmap?.results.length === 0 && !rawHeatmapLoading
},
],
maxYFromEvents: [
(s) => [s.heatmapElements],
(heatmapElements: HeatmapElement[]): number => {
if (!heatmapElements || heatmapElements.length === 0) {
return 0
}
return Math.max(...heatmapElements.map((el: HeatmapElement) => el.y))
},
],
// Derived height - maximum of calculated height from events and viewport height
heightOverride: [
(s) => [s.maxYFromEvents, s.windowHeight],
(maxYFromEvents: number, windowHeight: number): number => {
if (maxYFromEvents > 0) {
const calculatedHeight = Math.ceil((maxYFromEvents + 100) / 100) * 100
return Math.min(Math.max(calculatedHeight, windowHeight), MAX_HEATMAP_HEIGHT)
}
return Math.max(DEFAULT_HEATMAP_HEIGHT, windowHeight)
},
],
// True when captured points extend past the rendered canvas cap, so the overlay is clipped
isHeightCapped: [
(s) => [s.maxYFromEvents],
(maxYFromEvents: number): boolean => {
if (maxYFromEvents <= 0) {
return false
}
const calculatedHeight = Math.ceil((maxYFromEvents + 100) / 100) * 100
return calculatedHeight > MAX_HEATMAP_HEIGHT
},
],
// the one place the area bounds filter applies, so rendering (heatmapJsData) and
// click-to-view-events hit testing can't disagree about which points exist
filteredHeatmapElements: [
(s) => [s.heatmapElements, s.analysisWidth, s.heatmapBoundsFilter],
(
heatmapElements: HeatmapElement[],
analysisWidth: number,
heatmapBoundsFilter: HeatmapBoundsFilter | null
): HeatmapElement[] => {
if (!heatmapBoundsFilter) {
return heatmapElements
}
return heatmapElements.filter((element) =>
isWithinBounds(
{
x: Math.round(element.xPercentage * analysisWidth),
y: Math.round(element.y),
targetFixed: element.targetFixed,
},
heatmapBoundsFilter
)
)
},
],
heatmapJsData: [
(s) => [s.filteredHeatmapElements, s.analysisWidth, s.heatmapFixedPositionMode],
(
filteredHeatmapElements: HeatmapElement[],
analysisWidth: number,
heatmapFixedPositionMode: HeatmapFixedPositionMode
): HeatmapJsData => {
const data = filteredHeatmapElements.reduce((acc, element) => {
if (heatmapFixedPositionMode === 'hidden' && element.targetFixed) {
return acc
}
const y = Math.round(element.y)
const x = Math.round(element.xPercentage * analysisWidth)
acc.push({ x, y, value: element.count })
return acc
}, [] as HeatmapJsDataPoint[])
// Max is the highest value in the data set we have
const max = data.reduce((max, { value }) => Math.max(max, value), 0)
// TODO: Group based on some sensible resolutions (we can then use this for a hover state to show more detail)
return {
min: 0,
max,
data,
}
},
],
})),
listeners(({ actions, values, props }) => ({
setCommonFilters: () => {
// The open drill-down lists interactions for the filters it was opened with. Close it so it
// can't show sessions the new filters exclude; the user reselects a hotspot on the new overlay.
actions.clearSelectedArea()
actions.loadHeatmap()
},
setHistoryView: () => {
actions.clearSelectedArea()
actions.setIsReady(false)
actions.resetHeatmapData()
actions.loadHeatmap()
},
setHeatmapFilters: () => {
actions.loadHeatmap()
},
patchHeatmapFilters: ({ filters }) => {
// Clear old data when switching heatmap types
if (filters.type) {
actions.resetHeatmapData()
}
actions.loadHeatmap()
},
setHref: () => {
actions.loadHeatmap()
},
setSelectedArea: ({ area }) => {
if (area) {
actions.loadAreaEvents({})
actions.setShowEventsPanel(true)
}
},
loadMoreAreaEvents: async () => {
const area = values.selectedArea
const currentEvents = values.areaEvents
if (!area || !values.href || !currentEvents?.results) {
return
}
const { date_from, date_to, filter_test_accounts, cohort_ids, events } = values.effectiveCommonFilters
const { type } = values.heatmapFilters
const nextOffset = currentEvents.results.length
const apiURL = `${heatmapApiPath(props.context, 'events/')}${encodeParams(
{
type,
date_from,
date_to,
timestamp_from: values.dateRangeOverride?.timestamp_from,
timestamp_to: values.dateRangeOverride?.timestamp_to,
url_exact: values.hrefMatchType === 'exact' ? values.href : undefined,
url_pattern: values.hrefMatchType === 'pattern' ? values.href : undefined,
viewport_width_min: values.viewportRange.min,
viewport_width_max: values.viewportRange.max,
filter_test_accounts,
cohort_ids: cohort_ids && cohort_ids.length > 0 ? cohort_ids : undefined,
events: eventFilterParam(events),
points: JSON.stringify(area.points),
offset: nextOffset,
},
'?'
)}`
let response: Response
try {
response = await fetchHeatmapData(props, apiURL)
} catch (e) {
lemonToast.error(e instanceof Error ? e.message : 'Failed to load more events')
return
}
const newData: HeatmapEventsResponse = await response.json()
actions.loadMoreAreaEventsSuccess({
results: [...currentEvents.results, ...(newData.results || [])],
total_count: newData.total_count,
has_more: newData.has_more,
})
},
loadHeatmapFailure: ({ error }) => {
lemonToast.error(error || 'Heatmap query failed')
},
loadAreaEventsFailure: ({ error }) => {
lemonToast.error(error || 'Failed to load events for selected area')
},
})),
subscriptions(({ actions }) => ({
analysisWidth: () => {
actions.loadHeatmap()
},
})),
])