/**
* The session tab strip: one chip per opened conversation, rendered into the
* DOM seat at the head of the conversation column (see `tab-seat.ts` for why
* this is a DOM injection rather than a slot).
*
* A tab is a *view* of the open session, not a second navigation model:
* clicking a chip navigates through `ctx.uiWorkspace.openSession`, which is the
* one path that retains a target session; the owning component derives the
* strip from the open session plus the tab store.
*
* The active chip is derived, never stored: it is the chip whose session is the
* open one, so clicking a background chip immediately shows that chip active.
*
* Every affordance beyond "click to switch" is an explicit USER gesture, and
* each one maps to exactly one store action: middle-click closes, the context
* menu pins / renames / closes a range, a drag reorders, and a double-click
* edits the tab's own label. None of them can run on their own — the strip stays
* a record of what the user opened.
*/
import { useEffect, useMemo, useRef, useState } from 'react'
import { createPortal } from 'react-dom'
import {
IconCloseFillMedium,
IconPinFillMedium,
StateDot,
Tooltip,
type StateDotState,
} from '@deepseek-ai/dsh-client-ui-primitives'
import type { SessionId } from '@deepseek-ai/dsh-session/types'
import type { SessionsTabsProps } from './contract.ts'
import { mountTabSeat } from './tab-seat.ts'
import {
orderedTabs,
projectIndex,
tabIndicator,
type SessionTab,
type SessionTabIndicator,
} from './tabs.ts'
import { currentSessionId } from './tree.ts'
/** Dot state for one tab (the sidebar's session rows share this vocabulary). */
function dotState(indicator: SessionTabIndicator): StateDotState {
if (indicator.attention) return 'warning'
if (indicator.running) return 'ongoing'
return 'done'
}
/** Where the context menu is pinned, and which chip it belongs to. */
interface MenuAnchor {
readonly sessionId: SessionId
readonly x: number
readonly y: number
}
/** Which chip a drag is hovering, and which half of it. */
interface DropTarget {
readonly sessionId: SessionId
readonly side: 'before' | 'after'
}
/** In-flight inline label edit. */
interface LabelEdit {
readonly sessionId: SessionId
readonly draft: string
}
/** One row of the tab context menu. */
function MenuRow({
label,
onSelect,
disabled = false,
danger = false,
}: {
readonly label: string
readonly onSelect: () => void
readonly disabled?: boolean
readonly danger?: boolean
}) {
return (
)
}
/**
* Render the session tab strip into the conversation column's head seat.
* @param props - tab store, catalog/status hooks, navigation, locale.
* @returns the portal (or null until the column has mounted).
*/
export function SessionTabs({
useTabs,
actions,
useSessions,
useSessionStatus,
useWorkspaces,
activate,
rename,
t,
}: SessionsTabsProps) {
const tabs = useTabs(s => s.tabs)
const list = useSessions(s => s)
const statuses = useSessionStatus(s => s)
const currentId = useSessions(s => currentSessionId(s))
const workspaces = useWorkspaces(s => s.items)
// Session → owning project, in one pass over the workspace registry. This is
// what lets each chip name its project; without it a strip of session titles
// is ambiguous as soon as two projects are open.
const projects = useMemo(() => projectIndex(workspaces), [workspaces])
// The seat is a DOM node outside React's tree, so it cannot arrive through
// props; it is discovered once per mount and held in state to trigger the
// portal's first render when the column appears.
const [seat, setSeat] = useState(null)
// The scrolling row, for wheel redirection and keep-active-in-view.
const scrollRef = useRef(null)
// The open context menu, its chip, and its viewport position.
const [menu, setMenu] = useState(null)
// The chip whose label is being typed into, plus the in-progress text.
const [editing, setEditing] = useState(null)
// The chip being dragged and the chip/half it would land on.
const [dragging, setDragging] = useState(null)
const [dropTarget, setDropTarget] = useState(null)
// Timestamp of the last drag end: a drop must not also count as a click on
// the chip it landed on (which would navigate away from what was just moved).
const dragEndedAt = useRef(0)
useEffect(() => {
const mounted = mountTabSeat(setSeat)
// The column may already exist, in which case onReady fired synchronously
// during mountTabSeat and setSeat is already queued; adopt it here too so
// the very first paint has a host instead of waiting a frame.
if (mounted.host !== null) setSeat(mounted.host)
return () => {
mounted.dispose()
// The portal must stop targeting a removed node before the next mount.
setSeat(null)
}
}, [])
// The strip renders exactly the tabs the store holds. There is deliberately NO
// filtering against the session catalog and no "close tabs whose session
// vanished" sweep: a tab is removed when the USER closes it, and by nothing
// else. Trimming automatically also misfires — the catalog is briefly empty on
// every load, which deleted restored tabs before the sessions arrived.
const display = useMemo(() => orderedTabs(tabs, currentId), [tabs, currentId])
const index = useMemo(() => new Map(display.map((tab, at) => [tab.sessionId, at])), [display])
// With the row scrollable, the active chip can sit outside the viewport —
// e.g. after clicking a session in the sidebar that has a tab far to the
// right. Bring it into view on selection change. `block: 'nearest'` keeps
// this a horizontal-only scroll, and `inline: 'nearest'` avoids nudging the
// row when the chip is already fully visible.
useEffect(() => {
const el = scrollRef.current
if (el === null || currentId === undefined) return
const chip = el.querySelector(`[data-tab-session="${CSS.escape(currentId)}"]`)
chip?.scrollIntoView({ block: 'nearest', inline: 'nearest' })
}, [currentId, display.length])
// Dismiss the context menu on any interaction outside it. Pointerdown covers
// both buttons; Escape and a viewport change (which would leave a fixed menu
// pointing at the wrong chip) close it too. `capture` matters for the scroll
// case: the strip's own row scrolls without bubbling a scroll event up.
useEffect(() => {
if (menu === null) return
const dismiss = (): void => { setMenu(null) }
const onPointerDown = (event: PointerEvent): void => {
const target = event.target
if (target instanceof Element && target.closest('.wgTabMenu') !== null) return
dismiss()
}
const onKeyDown = (event: KeyboardEvent): void => {
if (event.key === 'Escape') dismiss()
}
document.addEventListener('pointerdown', onPointerDown, true)
document.addEventListener('keydown', onKeyDown)
window.addEventListener('resize', dismiss)
window.addEventListener('scroll', dismiss, true)
return () => {
document.removeEventListener('pointerdown', onPointerDown, true)
document.removeEventListener('keydown', onKeyDown)
window.removeEventListener('resize', dismiss)
window.removeEventListener('scroll', dismiss, true)
}
}, [menu])
if (seat === null || display.length === 0) return null
/** Commit the in-flight label edit (blank clears the override). */
const commitEdit = (): void => {
if (editing === null) return
actions.rename(editing.sessionId, editing.draft)
setEditing(null)
}
/** Start editing a tab's own label, pre-filled with what the chip shows. */
const startEdit = (sessionId: SessionId, current: string): void => {
setMenu(null)
setEditing({ sessionId, draft: current })
}
/** Translate a drop onto `target` into an index in the resulting strip. */
const dropIndexFor = (draggedSessionId: SessionId, target: DropTarget): number | null => {
const from = index.get(draggedSessionId)
const at = index.get(target.sessionId)
if (from === undefined || at === undefined || from === at) return null
// Insertion index in the CURRENT strip, then corrected for the removal the
// move implies: removing a chip before the insertion point shifts it left.
const insertion = at + (target.side === 'after' ? 1 : 0)
return from < insertion ? insertion - 1 : insertion
}
const chips = display.map((tab: SessionTab, at: number) => {
const summary = list.byId[tab.sessionId]
// A restored tab can render before its catalog row arrives. Show the
// session id meanwhile rather than an empty chip — the tab is real, and
// the title fills in as soon as the catalog catches up.
const sessionLabel = summary === undefined
? tab.sessionId
: summary.blank ? t('newSession') : summary.displayTitle
// The user's own label wins over the session title; blank means "follow the
// session", so the override is absent rather than empty.
const label = tab.title ?? sessionLabel
const active = tab.sessionId === currentId
const pinned = tab.pinned === true
const indicator = tabIndicator(summary, statuses.get(tab.sessionId))
// The project this session belongs to. Absent for a session that is in
// no workspace (a bare session, or one just created before the
// registry caught up) — the chip then shows the title alone rather
// than a placeholder.
const project = projects.get(tab.sessionId)
// Title attribute carries the full pair plus the directory, so the
// truncated chip text is recoverable on hover.
const tip = project === undefined
? label
: `${project.label} · ${label}\n${project.path}`
const drop = dropTarget !== null && dropTarget.sessionId === tab.sessionId ? dropTarget.side : null
const isEditing = editing !== null && editing.sessionId === tab.sessionId
const draft = isEditing && editing !== null ? editing.draft : ''
const className = [
'wgTab',
active ? 'wgTabActive' : '',
pinned ? 'wgTabPinned' : '',
dragging === tab.sessionId ? 'wgTabDragging' : '',
drop === 'before' ? 'wgTabDropBefore' : '',
drop === 'after' ? 'wgTabDropAfter' : '',
].filter(part => part !== '').join(' ')
return (
{
// Middle click closes, the way every other tab strip behaves. Only
// button 1: a right click opens the menu instead.
if (event.button !== 1) return
event.preventDefault()
actions.close(tab.sessionId)
}}
onContextMenu={(event) => {
event.preventDefault()
setEditing(null)
setMenu({
sessionId: tab.sessionId,
// Clamp inside the viewport so a chip near the right edge does not
// open a menu that runs off-screen.
x: Math.min(event.clientX, window.innerWidth - 208),
y: Math.min(event.clientY, window.innerHeight - 240),
})
}}
onDragStart={(event) => {
event.dataTransfer.effectAllowed = 'move'
event.dataTransfer.setData('text/plain', tab.sessionId)
setDragging(tab.sessionId)
setMenu(null)
}}
onDragOver={(event) => {
if (dragging === null || dragging === tab.sessionId) return
event.preventDefault()
event.dataTransfer.dropEffect = 'move'
const rect = event.currentTarget.getBoundingClientRect()
const side = event.clientX < rect.left + rect.width / 2 ? 'before' : 'after'
setDropTarget({ sessionId: tab.sessionId, side })
}}
onDrop={(event) => {
event.preventDefault()
if (dragging !== null && dropTarget !== null) {
const target = dropIndexFor(dragging, dropTarget)
if (target !== null) actions.move(dragging, target)
}
setDragging(null)
setDropTarget(null)
dragEndedAt.current = Date.now()
}}
onDragEnd={() => {
setDragging(null)
setDropTarget(null)
dragEndedAt.current = Date.now()
}}
>
{isEditing ? (
{ event.currentTarget.select() }}
onChange={(event) => { setEditing({ sessionId: tab.sessionId, draft: event.target.value }) }}
onClick={(event) => { event.stopPropagation() }}
onKeyDown={(event) => {
if (event.key === 'Enter') {
event.preventDefault()
commitEdit()
} else if (event.key === 'Escape') {
event.preventDefault()
setEditing(null)
}
}}
onBlur={() => { commitEdit() }}
/>
) : (
<>
{pinned && (
)}
>
)}
)
})
// The menu's chip, resolved against the current strip: a menu opened on a chip
// that has since disappeared renders nothing rather than acting on a stale id.
const menuTab = menu === null ? undefined : display.find(tab => tab.sessionId === menu.sessionId)
const menuIndex = menuTab === undefined ? -1 : at(display, menuTab)
const menuLabel = menuTab === undefined
? ''
: menuTab.title ?? list.byId[menuTab.sessionId]?.displayTitle ?? menuTab.sessionId
const menuPinned = menuTab?.pinned === true
const canCloseRight = menuIndex >= 0 && menuIndex < display.length - 1
return createPortal(
<>
{
// A plain wheel reports only `deltaY`, and the overflow here is
// horizontal, so without this the wheel would do nothing over the
// strip (or scroll the transcript behind it). Redirect the dominant
// delta to scrollLeft, and only swallow the event once there is
// somewhere left to scroll — otherwise a wheel at either end keeps
// propagating and the page still scrolls normally.
const el = event.currentTarget
if (el.scrollWidth <= el.clientWidth) return
const delta = Math.abs(event.deltaY) > Math.abs(event.deltaX) ? event.deltaY : event.deltaX
if (delta === 0) return
const atStart = el.scrollLeft <= 0 && delta < 0
const atEnd = el.scrollLeft + el.clientWidth >= el.scrollWidth - 1 && delta > 0
if (atStart || atEnd) return
el.scrollLeft += delta
event.preventDefault()
}}
>
{chips}
,
document.body,
)}
>,
seat,
)
}
/** Index of one tab in the strip, used by the menu's range actions. */
function at(tabs: readonly SessionTab[], target: SessionTab): number {
return tabs.findIndex(tab => tab.sessionId === target.sessionId)
}