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.

15.3 KB
Raw Blame
import { MakeLogicType, actions, connect, defaults, kea, listeners, path, reducers, selectors } from 'kea'
import { subscriptions } from 'kea-subscriptions'
import posthog from 'posthog-js'

import { notebookPanelLogic } from 'scenes/notebooks/NotebookPanel/notebookPanelLogic'
import { urls } from 'scenes/urls'

import { CANVAS_SIDE_PANEL_TABS, sidePanelLogic } from '~/layout/navigation-3000/sidepanel/sidePanelLogic'
import { sidePanelStateLogic } from '~/layout/navigation-3000/sidepanel/sidePanelStateLogic'
import { SidePanelTab } from '~/types'

import { sidepanelTicketsLogic } from 'products/conversations/frontend/components/SidePanel/sidepanelTicketsLogic'

import { projectSessionKey, readSessionValue, writeSessionValue } from './todaySessionStorage'
import { todayShellLogic } from './todayShellLogic'

export interface TodayContextPanelOffset {
    x: number
    y: number
}

/**
 * Where the PostHog AI button sits along the bottom edge of the scene. The user drags it between these, like the
 * toolbar. The top edge is left out because the scene header and its actions sit there. The values double as the
 * floating card's alignment to the button.
 */
export type TodayLauncherAlign = 'start' | 'center' | 'end'

const LAUNCHER_HIDDEN_HINT_MS = 6000

/** Matches the floating card, so docking keeps the panel's width. The dock silhouette uses it too. */
export const TODAY_SIDE_PANEL_DEFAULT_WIDTH = 340

/** The floating card as it was before a reload. The docked panel restores itself from the URL's `#panel` hash. */
interface TodayFloatingSession {
    tab: SidePanelTab
    offset: TodayContextPanelOffset
}

const FLOATING_SESSION_KEY = 'today-context-panel-floating'

/** How close to the right edge of the window a dragged panel must be released to dock. */
export const TODAY_CONTEXT_PANEL_DOCK_EDGE = 64

const NO_OFFSET: TodayContextPanelOffset = { x: 0, y: 0 }

/**
 * Tabs the top bar doesn't offer. Info is on its way out under the Today layout. Exports, Notebooks and Discussion
 * still open docked from their own entry points, such as "Add to notebook" or a comment button.
 */
const TABS_LEFT_OUT = [SidePanelTab.Info, SidePanelTab.Exports, SidePanelTab.Notebooks, SidePanelTab.Discussion]

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface todayContextPanelLogicValues {
    selectedNotebook: string // notebookPanelLogic
    enabledTabs: SidePanelTab[] // sidePanelLogic
    selectedTab: SidePanelTab | null // sidePanelStateLogic
    sidePanelOpen: boolean // sidePanelStateLogic
    canAccessTickets: boolean // sidepanelTicketsLogic
    myTicketsUrl: string // sidepanelTicketsLogic
    onAiPage: boolean // todayShellLogic
    activeTab: SidePanelTab
    canUndock: boolean
    dockHint: boolean
    docked: boolean
    floatingActiveTab: SidePanelTab
    floatingOffset: TodayContextPanelOffset
    floatingOpen: boolean
    floatingSession: TodayFloatingSession | null
    floatingTab: SidePanelTab
    fullScreenUrl: string | null
    launcherAlign: TodayLauncherAlign
    launcherHidden: boolean
    launcherHintVisible: boolean
    launcherShown: boolean
    panelTabs: SidePanelTab[]
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface todayContextPanelLogicActions {
    closeSidePanel: (tab?: SidePanelTab | undefined) => {
        tab: SidePanelTab | undefined
    } // sidePanelStateLogic
    openSidePanel: (
        tab: SidePanelTab,
        options?: string | undefined
    ) => {
        options: string | undefined
        tab: SidePanelTab
    } // sidePanelStateLogic
    close: () => {
        value: true
    }
    dock: () => {
        value: true
    }
    hideLauncher: () => {
        value: true
    }
    hideLauncherHint: () => {
        value: true
    }
    openFullScreen: () => {
        value: true
    }
    setDockHint: (dockHint: boolean) => {
        dockHint: boolean
    }
    setFloatingOffset: (offset: TodayContextPanelOffset) => {
        offset: TodayContextPanelOffset
    }
    setFloatingOpen: (open: boolean) => {
        open: boolean
    }
    setFloatingTab: (tab: SidePanelTab) => {
        tab: SidePanelTab
    }
    setLauncherAlign: (align: TodayLauncherAlign) => {
        align: TodayLauncherAlign
    }
    showLauncherHint: () => {
        value: true
    }
    togglePanelTab: (tab: SidePanelTab) => {
        tab: SidePanelTab
    }
    undock: () => {
        value: true
    }
}

// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface todayContextPanelLogicMeta {
    __keaTypeGenInternalSelectorTypes: {
        docked: (sidePanelOpen: boolean) => boolean
        floatingSession: (
            floatingOpen: boolean,
            floatingActiveTab: SidePanelTab,
            floatingOffset: TodayContextPanelOffset
        ) => TodayFloatingSession | null
        launcherHidden: (
            docked: boolean,
            launcherShown: boolean,
            floatingOpen: boolean,
            panelTabs: SidePanelTab[]
        ) => boolean
        panelTabs: (enabledTabs: SidePanelTab[]) => SidePanelTab[]
        floatingActiveTab: (floatingTab: SidePanelTab, enabledTabs: SidePanelTab[]) => SidePanelTab
        canUndock: (activeTab: SidePanelTab, onAiPage: boolean) => boolean
        activeTab: (docked: boolean, selectedTab: SidePanelTab | null, floatingActiveTab: SidePanelTab) => SidePanelTab
        fullScreenUrl: (
            activeTab: SidePanelTab,
            selectedNotebook: string,
            canAccessTickets: boolean,
            myTicketsUrl: string
        ) => string | null
    }
}

export type todayContextPanelLogicType = MakeLogicType<
    todayContextPanelLogicValues,
    todayContextPanelLogicActions,
    Record<string, any>,
    todayContextPanelLogicMeta
>

/**
 * The context panel outside the scene: a floating card over the main content, or docked in the side panel.
 * Both show the same panel, so only one of them is open at a time. PostHog AI is the panel's home tab.
 */
export const todayContextPanelLogic = kea<todayContextPanelLogicType>([
    path(['layout', 'today', 'todayContextPanelLogic']),
    connect(() => ({
        values: [
            sidePanelStateLogic,
            ['sidePanelOpen', 'selectedTab'],
            sidePanelLogic,
            ['enabledTabs'],
            notebookPanelLogic,
            ['selectedNotebook'],
            sidepanelTicketsLogic,
            ['canAccessTickets', 'myTicketsUrl'],
            todayShellLogic,
            ['onAiPage'],
        ],
        actions: [sidePanelStateLogic, ['openSidePanel', 'closeSidePanel']],
    })),
    actions({
        setFloatingOpen: (open: boolean) => ({ open }),
        setFloatingTab: (tab: SidePanelTab) => ({ tab }),
        setFloatingOffset: (offset: TodayContextPanelOffset) => ({ offset }),
        setDockHint: (dockHint: boolean) => ({ dockHint }),
        setLauncherAlign: (align: TodayLauncherAlign) => ({ align }),
        hideLauncher: true,
        showLauncherHint: true,
        hideLauncherHint: true,
        togglePanelTab: (tab: SidePanelTab) => ({ tab }),
        dock: true,
        undock: true,
        close: true,
        openFullScreen: true,
    }),
    // A reload opens the card where it was, as state rather than an action, so it doesn't count as the user opening it.
    defaults(() => {
        const saved = readSessionValue<TodayFloatingSession>(projectSessionKey(FLOATING_SESSION_KEY))
        return saved ? { floatingOpen: true, floatingTab: saved.tab, floatingOffset: saved.offset } : {}
    }),
    reducers({
        floatingOpen: [
            false,
            {
                setFloatingOpen: (_, { open }) => open,
                dock: () => false,
                undock: () => true,
            },
        ],
        floatingTab: [
            SidePanelTab.Max as SidePanelTab,
            {
                setFloatingTab: (_, { tab }) => tab,
            },
        ],
        // Kept across opens, so the panel comes back where the user left it.
        floatingOffset: [
            NO_OFFSET as TodayContextPanelOffset,
            {
                setFloatingOffset: (_, { offset }) => offset,
            },
        ],
        launcherAlign: [
            'end' as TodayLauncherAlign,
            { persist: true },
            {
                setLauncherAlign: (_, { align }) => align,
            },
        ],
        launcherShown: [
            false,
            { persist: true },
            {
                undock: () => true,
                // The card closes back into the floating button, so opening it floating counts as undocking.
                setFloatingOpen: (state, { open }) => open || state,
                dock: () => false,
                hideLauncher: () => false,
            },
        ],
        launcherHintVisible: [
            false,
            {
                showLauncherHint: () => true,
                hideLauncherHint: () => false,
                togglePanelTab: () => false,
            },
        ],
        dockHint: [
            false,
            {
                setDockHint: (_, { dockHint }) => dockHint,
                dock: () => false,
                setFloatingOpen: () => false,
            },
        ],
    }),
    selectors({
        docked: [(s) => [s.sidePanelOpen], (sidePanelOpen: boolean): boolean => sidePanelOpen],
        floatingSession: [
            (s) => [s.floatingOpen, s.floatingActiveTab, s.floatingOffset],
            (
                floatingOpen: boolean,
                floatingActiveTab: SidePanelTab,
                floatingOffset: TodayContextPanelOffset
            ): TodayFloatingSession | null =>
                floatingOpen ? { tab: floatingActiveTab, offset: floatingOffset } : null,
        ],
        /**
         * The button sinks away while docked, until the user undocks, and where the scene has no PostHog AI. The
         * open card hangs off it, so it shows for as long as the card is open.
         */
        launcherHidden: [
            (s) => [s.docked, s.launcherShown, s.floatingOpen, s.panelTabs],
            (docked: boolean, launcherShown: boolean, floatingOpen: boolean, panelTabs: SidePanelTab[]): boolean =>
                docked || !(launcherShown || floatingOpen) || !panelTabs.includes(SidePanelTab.Max),
        ],
        panelTabs: [
            (s) => [s.enabledTabs],
            // PostHog AI goes last, and only where the scene offers it. Canvas scenes bring their own chat.
            (enabledTabs: SidePanelTab[]): SidePanelTab[] => [
                ...enabledTabs.filter((tab) => tab !== SidePanelTab.Max && !TABS_LEFT_OUT.includes(tab)),
                ...(enabledTabs.includes(SidePanelTab.Max) ? [SidePanelTab.Max] : []),
            ],
        ],
        /**
         * A tab the scene no longer offers falls back to PostHog AI, like the docked panel closing on navigation.
         * Checked against every enabled tab, so an undocked tab the top bar leaves out stays open.
         */
        floatingActiveTab: [
            (s) => [s.floatingTab, s.enabledTabs],
            (floatingTab: SidePanelTab, enabledTabs: SidePanelTab[]): SidePanelTab =>
                enabledTabs.includes(floatingTab) && !CANVAS_SIDE_PANEL_TABS.includes(floatingTab)
                    ? floatingTab
                    : SidePanelTab.Max,
        ],
        /**
         * Canvas tabs read their body from the docked panel's selected tab, so they only dock. The AI page has no
         * floating panel to undock into.
         */
        canUndock: [
            (s) => [s.activeTab, s.onAiPage],
            (activeTab: SidePanelTab, onAiPage: boolean): boolean =>
                !onAiPage && !CANVAS_SIDE_PANEL_TABS.includes(activeTab),
        ],
        activeTab: [
            (s) => [s.docked, s.selectedTab, s.floatingActiveTab],
            (docked: boolean, selectedTab: SidePanelTab | null, floatingActiveTab: SidePanelTab): SidePanelTab =>
                docked && selectedTab ? selectedTab : floatingActiveTab,
        ],
        fullScreenUrl: [
            // PostHog AI's URL comes from the chat logic, which the header reads only while the panel is open.
            (s) => [s.activeTab, s.selectedNotebook, s.canAccessTickets, s.myTicketsUrl],
            (
                activeTab: SidePanelTab,
                selectedNotebook: string,
                canAccessTickets: boolean,
                myTicketsUrl: string
            ): string | null => {
                switch (activeTab) {
                    case SidePanelTab.Activity:
                        return urls.advancedActivityLogs()
                    case SidePanelTab.Notebooks:
                        return urls.notebook(selectedNotebook)
                    case SidePanelTab.Support:
                        return canAccessTickets ? myTicketsUrl : null
                    default:
                        return null
                }
            },
        ],
    }),
    subscriptions({
        floatingSession: (session: TodayFloatingSession | null) =>
            writeSessionValue(projectSessionKey(FLOATING_SESSION_KEY), session),
    }),
    listeners(({ actions, values }) => ({
        setLauncherAlign: ({ align }) => {
            posthog.capture('today ai button moved', { align })
        },
        hideLauncher: () => {
            posthog.capture('today ai button hidden')
            actions.showLauncherHint()
        },
        showLauncherHint: async (_, breakpoint) => {
            await breakpoint(LAUNCHER_HIDDEN_HINT_MS)
            actions.hideLauncherHint()
        },
        setFloatingOpen: ({ open }) => {
            // pinned: analytics event names
            posthog.capture(open ? 'today context panel opened' : 'today context panel closed', {
                mode: 'floating',
                tab: values.floatingActiveTab,
            })
            if (open && values.docked) {
                actions.closeSidePanel()
            }
        },
        // The top bar's tab buttons: the open tab closes the panel, a floating panel switches in place, and with the
        // panel closed the tab opens docked.
        togglePanelTab: ({ tab }) => {
            const open = values.docked || values.floatingOpen
            posthog.capture('today context panel tab toggled', { tab, docked: values.docked, open })
            if (open && values.activeTab === tab) {
                actions.close()
            } else if (values.floatingOpen && !CANVAS_SIDE_PANEL_TABS.includes(tab)) {
                actions.setFloatingTab(tab)
            } else {
                actions.openSidePanel(tab)
            }
        },
        dock: () => {
            posthog.capture('today context panel docked', { tab: values.floatingActiveTab })
            actions.openSidePanel(values.floatingActiveTab)
        },
        undock: () => {
            const tab = values.selectedTab ?? SidePanelTab.Max
            posthog.capture('today context panel undocked', { tab })
            actions.setFloatingTab(tab)
            actions.closeSidePanel()
        },
        close: () => {
            if (values.docked) {
                actions.closeSidePanel()
            } else {
                actions.setFloatingOpen(false)
            }
        },
        openFullScreen: () => {
            actions.close()
        },
        // The floating and docked panel are one panel, so docking any tab takes the floating card away.
        openSidePanel: () => {
            if (values.floatingOpen) {
                actions.setFloatingOpen(false)
            }
        },
    })),
])