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.

33.7 KB
Raw Blame
import { MakeLogicType, actions, connect, events, kea, listeners, path, reducers, selectors } from 'kea'
import { collectAllElementsDeep } from 'query-selector-shadow-dom'

import { EXPERIMENT_TARGET_SELECTOR } from 'lib/utils/actions'
import { debounce } from 'lib/utils/async'

import { actionsLogic } from '~/toolbar/shared/actions/actionsLogic'
import { actionsTabLogic } from '~/toolbar/shared/actions/actionsTabLogic'
import { experimentsTabLogic } from '~/toolbar/shared/experiments/experimentsTabLogic'
import { currentPageLogic } from '~/toolbar/shared/stats/currentPageLogic'
import { toolbarConfigLogic } from '~/toolbar/shared/toolbarConfigLogic'
import { toolbarPosthogJS } from '~/toolbar/shared/toolbarPosthogJS'
import { ActionElementWithMetadata, ActionForm, ElementWithMetadata } from '~/toolbar/shared/types'
import { ActionType } from '~/types'

import { elementToActionStep, getAllClickTargets, getElementForStep, getRectForElement } from '../utils'
import { FragileSelectorResult, checkSelectorFragilityCached } from '../utils/selectorQuality'
import { heatmapToolbarMenuLogic } from './heatmapToolbarMenuLogic'

export type ActionElementMap = Map<HTMLElement, ActionElementWithMetadata[]>
export type ElementMap = Map<HTMLElement, ElementWithMetadata>

const VIEWPORT_BUFFER_PX = 200

function getElementMetaWithSelectorQuality(
    element: HTMLElement | null,
    elementMap: ElementMap,
    actionsForElementMap: ActionElementMap,
    dataAttributes: string[]
): (ElementWithMetadata & { selectorQuality: FragileSelectorResult | null }) | null {
    if (!element) {
        return null
    }
    const meta = elementMap.get(element)
    if (!meta) {
        return null
    }
    const actions = actionsForElementMap.get(element)
    const actionStep = elementToActionStep(meta.element, dataAttributes)
    const selectorQuality = actionStep?.selector ? checkSelectorFragilityCached(actionStep.selector) : null

    return {
        ...meta,
        actionStep,
        actions: actions || [],
        selectorQuality,
    }
}

let zIndexCache = new WeakMap<Element, number>()

function clearZIndexCache(): void {
    zIndexCache = new WeakMap()
}

const getMaxZIndex = (element: Element): number => {
    const cached = zIndexCache.get(element)
    if (cached !== undefined) {
        return cached
    }

    let maxZIndex = 0
    let currentElement: Element | null = element

    while (currentElement) {
        const parentCached = zIndexCache.get(currentElement)
        if (parentCached !== undefined) {
            maxZIndex = Math.max(maxZIndex, parentCached)
            break
        }
        const zIndex = parseInt(getComputedStyle(currentElement).zIndex)
        if (!isNaN(zIndex) && zIndex > maxZIndex) {
            maxZIndex = zIndex
        }
        currentElement = currentElement.parentElement
    }

    zIndexCache.set(element, maxZIndex)
    return maxZIndex
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface elementsLogicValues {
    actionForm: ActionForm // actionsTabLogic
    href: string // currentPageLogic
    _actionElements: ElementWithMetadata[]
    _actionsForElementMap: ActionElementMap
    actionElements: ElementWithMetadata[]
    actionsForElementMap: ActionElementMap
    actionsListElements: ActionElementWithMetadata[]
    activeMeta:
        | (ElementWithMetadata & {
              selectorQuality: FragileSelectorResult | null
          })
        | null
    activeMetaIsSelected: boolean
    allInspectElements: HTMLElement[]
    displayActionElements: boolean
    elementMap: ElementMap
    elementsToDisplay: ElementWithMetadata[]
    elementsToDisplayRaw: ElementWithMetadata[]
    elementsWithActions: HTMLElement[]
    enabledLast: 'heatmap' | 'inspect' | null
    heatmapElements: ElementWithMetadata[]
    heatmapEnabled: boolean
    highlightElement: HTMLElement | null
    highlightElementMeta:
        | (ElementWithMetadata & {
              selectorQuality: FragileSelectorResult | null
          })
        | null
    hoverElement: HTMLElement | null
    hoverElementMeta:
        | (ElementWithMetadata & {
              selectorQuality: FragileSelectorResult | null
          })
        | null
    inspectElements: ElementWithMetadata[]
    inspectEnabled: boolean
    inspectEnabledRaw: boolean
    labelsToDisplay: ElementWithMetadata[]
    rectUpdateCounter: number
    relativePositionCompensation: number
    selectedElement: HTMLElement | null
    selectedElementMeta:
        | (ElementWithMetadata & {
              selectorQuality: FragileSelectorResult | null
          })
        | null
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface elementsLogicActions {
    newAction: (element?: HTMLElement | undefined) => {
        element: HTMLElement | null
    } // actionsTabLogic
    selectAction: (id: number | null) => {
        id: number | null
    } // actionsTabLogic
    createAction: (element: HTMLElement) => {
        element: HTMLElement
    }
    disableInspect: () => {
        value: true
    }
    enableInspect: () => {
        value: true
    }
    selectElement: (element: HTMLElement | null) => {
        element: HTMLElement | null
    }
    setHighlightElement: (element: HTMLElement | null) => {
        element: HTMLElement | null
    }
    setHoverElement: (element: HTMLElement | null) => {
        element: HTMLElement | null
    }
    setRelativePositionCompensation: (compensation: number) => {
        compensation: number
    }
    setSelectedElement: (element: HTMLElement | null) => {
        element: HTMLElement | null
    }
    updateRects: () => {
        value: true
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface elementsLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        activeMetaIsSelected: (
            selectedElementMeta:
                | (ElementWithMetadata & {
                      selectorQuality: FragileSelectorResult | null
                  })
                | null,
            activeMeta:
                | (ElementWithMetadata & {
                      selectorQuality: FragileSelectorResult | null
                  })
                | null
        ) => boolean
        inspectEnabled: (
            inspectEnabledRaw: boolean,
            inspectingElement: number | null,
            buttonActionsVisible: boolean,
            inspectingElement2: number | null
        ) => boolean
        heatmapEnabled: (heatmapEnabled: boolean) => boolean
        heatmapElements: (
            countedElements: import('~/toolbar/shared/types').CountedHTMLElement[],
            rectUpdateCounter: number,
            buttonVisible: boolean
        ) => ElementWithMetadata[]
        allInspectElements: (inspectEnabled: boolean, href: string) => HTMLElement[]
        inspectElements: (
            allInspectElements: HTMLElement[],
            rectUpdateCounter: number,
            buttonVisible: boolean
        ) => ElementWithMetadata[]
        displayActionElements: (buttonActionsVisible: boolean) => boolean
        _actionElements: (displayActionElements: boolean, actionForm: ActionForm) => ElementWithMetadata[]
        actionElements: (
            _actionElements: ElementWithMetadata[],
            rectUpdateCounter: number,
            buttonVisible: boolean
        ) => ElementWithMetadata[]
        elementMap: (
            heatmapElements: ElementWithMetadata[],
            inspectElements: ElementWithMetadata[],
            actionElements: ElementWithMetadata[],
            actionsListElements: ActionElementWithMetadata[]
        ) => ElementMap
        _actionsForElementMap: (sortedActions: ActionType[]) => ActionElementMap
        actionsForElementMap: (
            _actionsForElementMap: ActionElementMap,
            rectUpdateCounter: number,
            buttonVisible: boolean
        ) => ActionElementMap
        elementsWithActions: (actionsForElementMap: ActionElementMap) => HTMLElement[]
        actionsListElements: (actionsForElementMap: ActionElementMap) => ActionElementWithMetadata[]
        elementsToDisplayRaw: (
            displayActionElements: boolean,
            actionElements: ElementWithMetadata[],
            inspectElements: ElementWithMetadata[],
            actionsListElements: ActionElementWithMetadata[],
            selectedAction: ActionType | null | import('~/toolbar/shared/types').ActionDraftType
        ) => ElementWithMetadata[]
        elementsToDisplay: (elementsToDisplayRaw: ElementWithMetadata[]) => ElementWithMetadata[]
        labelsToDisplay: (
            displayActionElements: boolean,
            actionElements: ElementWithMetadata[],
            actionsListElements: ActionElementWithMetadata[],
            selectedAction: ActionType | null | import('~/toolbar/shared/types').ActionDraftType
        ) => ElementWithMetadata[]
        selectedElementMeta: (
            selectedElement: HTMLElement | null,
            elementMap: ElementMap,
            actionsForElementMap: ActionElementMap,
            dataAttributes: string[]
        ) =>
            | (ElementWithMetadata & {
                  selectorQuality: FragileSelectorResult | null
              })
            | null
        hoverElementMeta: (
            hoverElement: HTMLElement | null,
            elementMap: ElementMap,
            actionsForElementMap: ActionElementMap,
            dataAttributes: string[]
        ) =>
            | (ElementWithMetadata & {
                  selectorQuality: FragileSelectorResult | null
              })
            | null
        highlightElementMeta: (
            highlightElement: HTMLElement | null,
            elementMap: ElementMap,
            actionsForElementMap: ActionElementMap,
            dataAttributes: string[]
        ) =>
            | (ElementWithMetadata & {
                  selectorQuality: FragileSelectorResult | null
              })
            | null
        activeMeta: (
            selectedElementMeta:
                | (ElementWithMetadata & {
                      selectorQuality: FragileSelectorResult | null
                  })
                | null,
            hoverElementMeta:
                | (ElementWithMetadata & {
                      selectorQuality: FragileSelectorResult | null
                  })
                | null
        ) =>
            | (ElementWithMetadata & {
                  selectorQuality: FragileSelectorResult | null
              })
            | null
    }
}

export type elementsLogicType = MakeLogicType<
    elementsLogicValues,
    elementsLogicActions,
    Record<string, any>,
    elementsLogicMeta
>

export const elementsLogic = kea<elementsLogicType>([
    path(['toolbar', 'elements', 'elementsLogic']),

    connect(() => ({
        values: [actionsTabLogic, ['actionForm'], currentPageLogic, ['href']],
        actions: [actionsTabLogic, ['selectAction', 'newAction']],
    })),
    actions({
        enableInspect: true,
        disableInspect: true,

        selectElement: (element: HTMLElement | null) => ({
            element,
        }),
        createAction: (element: HTMLElement) => ({ element }),

        updateRects: true,
        setHoverElement: (element: HTMLElement | null) => ({ element }),
        setHighlightElement: (element: HTMLElement | null) => ({ element }),
        setSelectedElement: (element: HTMLElement | null) => ({ element }),

        setRelativePositionCompensation: (compensation: number) => ({ compensation }),
    }),
    reducers(() => ({
        inspectEnabledRaw: [
            false,
            {
                enableInspect: () => true,
                disableInspect: () => false,
            },
        ],
        rectUpdateCounter: [
            0,
            {
                updateRects: (state) => state + 1,
            },
        ],
        hoverElement: [
            null as HTMLElement | null,
            {
                setHoverElement: (_, { element }) => element,
                enableInspect: () => null,
                disableInspect: () => null,
                createAction: () => null,
                selectElement: () => null,
            },
        ],
        highlightElement: [
            null as HTMLElement | null,
            {
                setHighlightElement: (_, { element }) => element,
                setHoverElement: () => null,
                setSelectedElement: () => null,
                selectElement: () => null,
                disableInspect: () => null,
                createAction: () => null,
            },
        ],
        selectedElement: [
            null as HTMLElement | null,
            {
                setSelectedElement: (_, { element }) => element,
                disableInspect: () => null,
                createAction: () => null,
                [heatmapToolbarMenuLogic.actionTypes.disableHeatmap]: () => null,
                selectAction: () => null,
            },
        ],
        enabledLast: [
            null as null | 'inspect' | 'heatmap',
            {
                // keep track of what to disable first with ESC
                enableInspect: () => 'inspect',
                [heatmapToolbarMenuLogic.actionTypes.enableHeatmap]: () => 'heatmap',
            },
        ],
        relativePositionCompensation: [
            0,
            {
                setRelativePositionCompensation: (_, { compensation }) => compensation,
            },
        ],
    })),
    selectors({
        activeMetaIsSelected: [
            (s) => [s.selectedElementMeta, s.activeMeta],
            (
                selectedElementMeta:
                    | (ElementWithMetadata & {
                          selectorQuality: FragileSelectorResult | null
                      })
                    | null,
                activeMeta:
                    | (ElementWithMetadata & {
                          selectorQuality: FragileSelectorResult | null
                      })
                    | null
            ) => {
                return !!selectedElementMeta && !!activeMeta && selectedElementMeta.element === activeMeta.element
            },
        ],
        inspectEnabled: [
            (s) => [
                s.inspectEnabledRaw,
                actionsTabLogic.selectors.inspectingElement,
                actionsTabLogic.selectors.buttonActionsVisible,
                experimentsTabLogic.selectors.inspectingElement,
            ],
            (
                inspectEnabledRaw: boolean,
                actionsInspectingElement: number | null,
                actionsButtonActionsVisible: boolean,
                experimentsInspectingElement: number | null
            ) => {
                return (
                    inspectEnabledRaw ||
                    (actionsButtonActionsVisible && actionsInspectingElement !== null) ||
                    experimentsInspectingElement !== null
                )
            },
        ],

        heatmapEnabled: [
            () => [heatmapToolbarMenuLogic.selectors.heatmapEnabled],
            (heatmapEnabled: boolean) => heatmapEnabled,
        ],

        heatmapElements: [
            (s) => [
                heatmapToolbarMenuLogic.selectors.countedElements,
                s.rectUpdateCounter,
                toolbarConfigLogic.selectors.buttonVisible,
            ],
            (countedElements: import('~/toolbar/shared/types').CountedHTMLElement[]) => {
                const windowHeight = window.innerHeight

                const result: ElementWithMetadata[] = []

                for (const e of countedElements) {
                    if (e.visible === false) {
                        continue
                    }
                    const rect = getRectForElement(e.element)
                    const inViewport =
                        rect.bottom >= -VIEWPORT_BUFFER_PX && rect.top <= windowHeight + VIEWPORT_BUFFER_PX

                    if (inViewport) {
                        result.push({ ...e, rect } as ElementWithMetadata)
                    }
                }

                return result
            },
        ],

        allInspectElements: [
            (s) => [s.inspectEnabled, s.href],
            (inspectEnabled: boolean) => {
                if (!inspectEnabled) {
                    return []
                }
                const inspectForExperiment =
                    experimentsTabLogic.values.buttonExperimentsVisible &&
                    experimentsTabLogic.values.inspectingElement !== null
                const selector = inspectForExperiment
                    ? experimentsTabLogic.values.elementSelector || EXPERIMENT_TARGET_SELECTOR
                    : undefined
                return getAllClickTargets(undefined, selector)
            },
        ],

        inspectElements: [
            (s) => [s.allInspectElements, s.rectUpdateCounter, toolbarConfigLogic.selectors.buttonVisible],
            (allInspectElements: HTMLElement[]) =>
                allInspectElements
                    .map(
                        (element) =>
                            ({
                                element,
                                rect: getRectForElement(element),
                            }) as ElementWithMetadata
                    )
                    .filter((e) => e.rect && e.rect.width * e.rect.height > 0),
        ],

        displayActionElements: [
            () => [actionsTabLogic.selectors.buttonActionsVisible],
            (buttonActionsVisible: boolean) => {
                return buttonActionsVisible
            },
        ],

        _actionElements: [
            (s) => [s.displayActionElements, s.actionForm],
            (displayActionElements: boolean, actionForm: ActionForm): ElementWithMetadata[] => {
                if (displayActionElements && actionForm?.steps) {
                    const allElements = collectAllElementsDeep('*', document)
                    const steps: ElementWithMetadata[] = []
                    actionForm.steps.forEach((step, index) => {
                        const element = getElementForStep(step, allElements)
                        if (element) {
                            steps.push({
                                element,
                                index,
                            })
                        }
                    })
                    return steps
                }
                return [] as ElementWithMetadata[]
            },
        ],

        actionElements: [
            (s) => [s._actionElements, s.rectUpdateCounter, toolbarConfigLogic.selectors.buttonVisible],
            (actionElements: ElementWithMetadata[]) =>
                actionElements.map((element) =>
                    element.element ? { ...element, rect: getRectForElement(element.element) } : element
                ),
        ],

        elementMap: [
            (s) => [s.heatmapElements, s.inspectElements, s.actionElements, s.actionsListElements],
            (
                heatmapElements: ElementWithMetadata[],
                inspectElements: ElementWithMetadata[],
                actionElements: ElementWithMetadata[],
                actionsListElements: ActionElementWithMetadata[]
            ): ElementMap => {
                const elementMap = new Map<HTMLElement, ElementWithMetadata>()

                const addElements = (e: ElementWithMetadata): void => {
                    const elementWithMetadata: ElementWithMetadata = { ...e }
                    if (elementMap.get(e.element)) {
                        elementMap.set(e.element, { ...elementMap.get(e.element), ...elementWithMetadata })
                    } else {
                        elementMap.set(e.element, elementWithMetadata)
                    }
                }

                inspectElements.forEach(addElements)
                heatmapElements.forEach(addElements)
                actionElements.forEach(addElements)
                actionsListElements.forEach(addElements)

                return elementMap
            },
        ],

        _actionsForElementMap: [
            () => [actionsLogic.selectors.sortedActions],
            (sortedActions: ActionType[]): ActionElementMap => {
                const allElements = collectAllElementsDeep('*', document)
                const actionsForElementMap = new Map<HTMLElement, ActionElementWithMetadata[]>()
                sortedActions.forEach((action, index) => {
                    action.steps
                        ?.filter((step) => step.event === '$autocapture')
                        .forEach((step) => {
                            const element = getElementForStep(step, allElements)
                            if (element) {
                                const rect = getRectForElement(element)
                                let array = actionsForElementMap.get(element)
                                if (!array) {
                                    array = []
                                    actionsForElementMap.set(element, array)
                                }
                                array.push({ action, step, element, rect, index })
                            }
                        })
                })
                return actionsForElementMap
            },
        ],

        actionsForElementMap: [
            (s) => [s._actionsForElementMap, s.rectUpdateCounter, toolbarConfigLogic.selectors.buttonVisible],
            (actionsForElementMap: ActionElementMap): ActionElementMap => {
                // We recalculate the rects here to avoid calling the expensive getElementForStep
                actionsForElementMap.forEach((actions, element) => {
                    actions.forEach((action) => {
                        action.rect = getRectForElement(element)
                    })
                })

                return actionsForElementMap
            },
        ],

        elementsWithActions: [
            (s) => [s.actionsForElementMap],
            (actionsForElementMap: ActionElementMap) => [...(actionsForElementMap.keys() as unknown as HTMLElement[])],
        ],

        actionsListElements: [
            (s) => [s.actionsForElementMap],
            (actionsForElementMap: ActionElementMap) =>
                [...(actionsForElementMap.values() as unknown as ActionElementWithMetadata[][])].map((a) => a[0]),
        ],

        elementsToDisplayRaw: [
            (s) => [
                s.displayActionElements,
                s.actionElements,
                s.inspectElements,
                s.actionsListElements,
                actionsTabLogic.selectors.selectedAction,
            ],
            (
                displayActionElements: boolean,
                actionElements: ElementWithMetadata[],
                inspectElements: ElementWithMetadata[],
                actionsListElements: ActionElementWithMetadata[],
                selectedAction: ActionType | null | import('~/toolbar/shared/types').ActionDraftType
            ) => {
                if (inspectElements.length > 0) {
                    return inspectElements
                }
                if (displayActionElements && selectedAction && actionElements.length > 0) {
                    return actionElements
                }
                if (displayActionElements && !selectedAction && actionsListElements.length > 0) {
                    return actionsListElements
                }
                return []
            },
        ],

        elementsToDisplay: [
            (s) => [s.elementsToDisplayRaw],
            (elementsToDisplayRaw: ElementWithMetadata[]) => {
                const result: ElementWithMetadata[] = []
                elementsToDisplayRaw.forEach((element) => {
                    const { rect, visible } = element
                    // visible when undefined is ignored
                    if (rect && rect.width > 0 && rect.height > 0 && visible !== false) {
                        result.push({
                            ...element,
                            // being able to hover over elements might rely on their original z-index
                            // so we copy it over to the toolbar element
                            apparentZIndex: getMaxZIndex(element.element),
                        })
                    }
                })

                return result
            },
        ],

        labelsToDisplay: [
            (s) => [
                s.displayActionElements,
                s.actionElements,
                s.actionsListElements,
                actionsTabLogic.selectors.selectedAction,
            ],
            (
                displayActionElements: boolean,
                actionElements: ElementWithMetadata[],
                actionsListElements: ActionElementWithMetadata[],
                selectedAction: ActionType | null | import('~/toolbar/shared/types').ActionDraftType
            ) => {
                if (displayActionElements && selectedAction && actionElements.length > 0) {
                    return actionElements
                }
                if (displayActionElements && !selectedAction && actionsListElements.length > 0) {
                    return actionsListElements
                }
                return []
            },
        ],

        selectedElementMeta: [
            (s) => [
                s.selectedElement,
                s.elementMap,
                s.actionsForElementMap,
                toolbarConfigLogic.selectors.dataAttributes,
            ],
            (
                selectedElement: HTMLElement | null,
                elementMap: ElementMap,
                actionsForElementMap: ActionElementMap,
                dataAttributes: string[]
            ) => getElementMetaWithSelectorQuality(selectedElement, elementMap, actionsForElementMap, dataAttributes),
        ],

        hoverElementMeta: [
            (s) => [s.hoverElement, s.elementMap, s.actionsForElementMap, toolbarConfigLogic.selectors.dataAttributes],
            (
                hoverElement: HTMLElement | null,
                elementMap: ElementMap,
                actionsForElementMap: ActionElementMap,
                dataAttributes: string[]
            ) => getElementMetaWithSelectorQuality(hoverElement, elementMap, actionsForElementMap, dataAttributes),
        ],

        highlightElementMeta: [
            (s) => [
                s.highlightElement,
                s.elementMap,
                s.actionsForElementMap,
                toolbarConfigLogic.selectors.dataAttributes,
            ],
            (
                highlightElement: HTMLElement | null,
                elementMap: ElementMap,
                actionsForElementMap: ActionElementMap,
                dataAttributes: string[]
            ) => getElementMetaWithSelectorQuality(highlightElement, elementMap, actionsForElementMap, dataAttributes),
        ],
        activeMeta: [
            (s) => [s.selectedElementMeta, s.hoverElementMeta],
            (
                selectedElementMeta:
                    | (ElementWithMetadata & {
                          selectorQuality: FragileSelectorResult | null
                      })
                    | null,
                hoverElementMeta:
                    | (ElementWithMetadata & {
                          selectorQuality: FragileSelectorResult | null
                      })
                    | null
            ) => {
                return selectedElementMeta || hoverElementMeta
            },
        ],
    }),
    listeners(({ actions, values }) => ({
        updateRects: () => {
            clearZIndexCache()
        },
        enableInspect: () => {
            toolbarPosthogJS.capture('toolbar mode triggered', { mode: 'inspect', enabled: true })
            actionsLogic.actions.getActions()
        },
        disableInspect: () => {
            toolbarPosthogJS.capture('toolbar mode triggered', { mode: 'inspect', enabled: false })
        },
        selectElement: ({ element }) => {
            const inspectForAction =
                actionsTabLogic.values.buttonActionsVisible && actionsTabLogic.values.inspectingElement !== null

            const inspectForExperiment =
                experimentsTabLogic.values.buttonExperimentsVisible &&
                experimentsTabLogic.values.inspectingElement !== null

            if (inspectForAction) {
                actions.setHoverElement(null)
                if (element) {
                    actionsTabLogic.actions.inspectElementSelected(element, actionsTabLogic.values.inspectingElement)
                }
            } else {
                actions.setSelectedElement(element)
            }

            if (inspectForExperiment) {
                actions.setHoverElement(null)
                if (element) {
                    experimentsTabLogic.actions.inspectElementSelected(
                        element,
                        experimentsTabLogic.values.selectedVariant,
                        experimentsTabLogic.values.inspectingElement
                    )
                }
            }

            // Get list of data-* attributes in the element
            const data_attributes = []
            if (element?.attributes) {
                for (let i = 0; i < element.attributes.length; i++) {
                    const name = element.attributes.item(i)?.nodeName
                    if (name && name.indexOf('data-') > -1) {
                        data_attributes.push(name)
                    }
                }
            }

            const meta = getElementMetaWithSelectorQuality(
                element,
                values.elementMap,
                values.actionsForElementMap,
                toolbarConfigLogic.values.dataAttributes
            )
            const selector = meta?.actionStep?.selector

            toolbarPosthogJS.capture('toolbar selected HTML element', {
                element_tag: element?.tagName.toLowerCase() ?? null,
                element_type: (element as HTMLInputElement)?.type ?? null,
                has_href: !!(element as HTMLAnchorElement)?.href,
                has_class: !!element?.className,
                has_id: !!element?.id,
                has_name: !!(element as HTMLInputElement)?.name,
                has_data_attr: data_attributes.includes('data-attr'),
                data_attributes: data_attributes,
                attribute_length: element?.attributes.length ?? null,
                selector_quality: meta?.selectorQuality?.isFragile ? 'fragile' : 'good',
                selector_has_position_selectors: selector?.includes(':nth-') ?? false,
                selector_depth: selector
                    ? selector.split(/\s+/).filter((part) => part !== '>' && part !== '+' && part !== '~').length
                    : null,
            })
        },
        createAction: ({ element }) => {
            actions.selectElement(null)
            // this just sets the action form
            actions.newAction(element)
        },
    })),
    events(({ cache, values, actions }) => ({
        afterMount: () => {
            cache.updateRelativePosition = debounce(() => {
                const relativePositionCompensation =
                    window.getComputedStyle(document.body).position === 'relative'
                        ? document.documentElement.getBoundingClientRect().y - document.body.getBoundingClientRect().y
                        : 0
                if (relativePositionCompensation !== values.relativePositionCompensation) {
                    actions.setRelativePositionCompensation(relativePositionCompensation)
                }
            }, 100)
            // Add event listeners using disposables
            cache.disposables.add(() => {
                const onClick = (): void => actions.updateRects()
                window.addEventListener('click', onClick)
                return () => window.removeEventListener('click', onClick)
            }, 'clickListener')

            const onScrollResize = (): void => {
                if (!cache.rectUpdateScheduled) {
                    cache.rectUpdateScheduled = true
                    actions.updateRects()
                    cache.updateRelativePosition()
                    requestAnimationFrame(() => {
                        cache.rectUpdateScheduled = false
                    })
                }
            }

            cache.disposables.add(() => {
                window.addEventListener('resize', onScrollResize)
                return () => window.removeEventListener('resize', onScrollResize)
            }, 'resizeListener')

            cache.disposables.add(() => {
                const onKeyDown = (e: KeyboardEvent): void => {
                    if (e.keyCode !== 27) {
                        return
                    }
                    if (heatmapToolbarMenuLogic.values.areaSelectionActive) {
                        heatmapToolbarMenuLogic.actions.cancelAreaSelection()
                        return
                    }
                    if (values.hoverElement) {
                        actions.setHoverElement(null)
                    }
                    if (values.selectedElement) {
                        actions.setSelectedElement(null)
                        return
                    }
                    if (values.enabledLast === 'heatmap' && values.heatmapEnabled) {
                        heatmapToolbarMenuLogic.actions.disableHeatmap()
                        return
                    }
                    if (values.inspectEnabled) {
                        actions.disableInspect()
                        return
                    }
                    if (values.heatmapEnabled) {
                        heatmapToolbarMenuLogic.actions.disableHeatmap()
                        return
                    }
                }
                window.addEventListener('keydown', onKeyDown)
                return () => window.removeEventListener('keydown', onKeyDown)
            }, 'keydownListener')

            cache.disposables.add(() => {
                window.document.addEventListener('scroll', onScrollResize, { capture: true, passive: true })
                return () => window.document.removeEventListener('scroll', onScrollResize, { capture: true })
            }, 'scrollListener')
            cache.updateRelativePosition()
        },
    })),
])