: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, 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)
}
},
})),
])