workspace-groups-remote/src/client/SessionTabs.tsx

481 lines
19 KiB
TypeScript

/**
* 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 (
<button
type="button"
role="menuitem"
className={`wgTabMenuItem${danger ? ' wgTabMenuDanger' : ''}`}
disabled={disabled}
onClick={onSelect}
>
{label}
</button>
)
}
/**
* 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<HTMLElement | null>(null)
// The scrolling row, for wheel redirection and keep-active-in-view.
const scrollRef = useRef<HTMLDivElement | null>(null)
// The open context menu, its chip, and its viewport position.
const [menu, setMenu] = useState<MenuAnchor | null>(null)
// The chip whose label is being typed into, plus the in-progress text.
const [editing, setEditing] = useState<LabelEdit | null>(null)
// The chip being dragged and the chip/half it would land on.
const [dragging, setDragging] = useState<SessionId | null>(null)
const [dropTarget, setDropTarget] = useState<DropTarget | null>(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<HTMLElement>(`[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 (
<div
key={tab.order}
className={className}
data-tab-session={tab.sessionId}
{...(project !== undefined ? { 'data-tab-project': project.workspaceId } : {})}
draggable={!isEditing}
onAuxClick={(event) => {
// 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 ? (
<input
className="wgTabRename"
value={draft}
placeholder={t('tabs.renamePlaceholder')}
aria-label={t('tabs.rename')}
autoFocus
onFocus={(event) => { 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() }}
/>
) : (
<>
<button
type="button"
role="tab"
aria-selected={active}
className="wgTabMain"
title={pinned ? `${t('tabs.pinned')} · ${tip}` : tip}
onClick={() => {
if (Date.now() - dragEndedAt.current < 250) return
activate(tab.sessionId)
}}
onDoubleClick={() => { startEdit(tab.sessionId, label) }}
>
<span className="wgTabStatus" data-tab-state={indicator.attention ? 'attention' : indicator.running ? 'running' : indicator.unread ? 'unread' : indicator.settled ? 'settled' : 'idle'}>
<StateDot state={dotState(indicator)} />
</span>
{/* Two stacked lines, folder-style: the project (short, quiet)
over the session title (long, primary). The project line is
omitted for a session in no workspace, which lets the title
use the full height rather than leaving a blank row. */}
<span className="wgTabText">
{project !== undefined && (
<span className="wgTabProject" title={project.path}>{project.label}</span>
)}
<span className="wgTabLabel">{label}</span>
</span>
</button>
{pinned && (
<span className="wgTabPin" title={t('tabs.pinned')} aria-hidden>
<IconPinFillMedium />
</span>
)}
<Tooltip label={t('tabs.close')} side="top" delayMs={600}>
<button
type="button"
className="wgTabClose"
aria-label={`${t('tabs.close')} ${label}`}
onClick={(event) => {
event.stopPropagation()
actions.close(tab.sessionId)
}}
>
<IconCloseFillMedium />
</button>
</Tooltip>
</>
)}
</div>
)
})
// 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(
<>
<div className="wgTabs" role="tablist" aria-label={t('tabs.aria')}>
<div
className="wgTabsScroll"
ref={scrollRef}
onWheel={(event) => {
// 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}
</div>
</div>
{menu !== null && menuTab !== undefined && createPortal(
<div
className="wgTabMenu"
role="menu"
aria-label={menuLabel}
style={{ left: menu.x, top: menu.y }}
>
<MenuRow
label={menuPinned ? t('tabs.unpin') : t('tabs.pin')}
onSelect={() => {
actions.pin(menu.sessionId)
setMenu(null)
}}
/>
<MenuRow
label={t('tabs.rename')}
onSelect={() => { startEdit(menu.sessionId, menuLabel) }}
/>
<MenuRow
label={t('tabs.renameSession')}
onSelect={() => {
setMenu(null)
rename(menu.sessionId, menuLabel)
}}
/>
<div className="wgTabMenuSeparator" role="separator" />
<MenuRow
label={t('tabs.close')}
onSelect={() => {
setMenu(null)
actions.close(menu.sessionId)
}}
/>
<MenuRow
label={t('tabs.closeOthers')}
onSelect={() => {
setMenu(null)
actions.closeOthers(menu.sessionId)
}}
/>
<MenuRow
label={t('tabs.closeRight')}
disabled={!canCloseRight}
onSelect={() => {
setMenu(null)
actions.closeAfter(menu.sessionId)
}}
/>
</div>,
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)
}