mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-19 17:01:37 +03:00
fix(app): drive the composer focus handoff with an explicit state machine (#61924)
This commit is contained in:
committed by
GitHub
Unverified
parent
c1cfbd1f47
commit
65d59b9847
@@ -790,6 +790,45 @@ test("the title and message stay stable through worktree creation", async ({ pag
|
||||
await expect.poll(() => mock.calls).toEqual(["worktree", "session", "prompt"])
|
||||
})
|
||||
|
||||
test("the created session's composer keeps focus and a caret placed mid-draft", async ({ page }) => {
|
||||
const mock = await openWorktreeDraft(page, pendingDraft)
|
||||
const pending = await submitPending(page, mock)
|
||||
await draftFollowUp(page)
|
||||
// The start of the second line: not where focusing the editor alone would put the caret.
|
||||
await editor(page).press("ControlOrMeta+End")
|
||||
await editor(page).press("Home")
|
||||
mock.worktree.resolve({ status: 200, json: { directory: workspace } })
|
||||
|
||||
await expect(page.locator("[data-session-title]").getByRole("heading", { level: 1 })).toHaveText(
|
||||
"Created workspace session",
|
||||
)
|
||||
await expect(pending.shimmer).toHaveCount(0)
|
||||
await expect(editor(page)).toHaveText(followUp)
|
||||
await expect(editor(page)).toBeFocused()
|
||||
// Types into whatever holds focus, without focusing the editor again.
|
||||
await page.keyboard.type("Also: ")
|
||||
await expect(editor(page)).toHaveText(followUp.replace("\n", "\nAlso: "))
|
||||
})
|
||||
|
||||
test("a user who leaves the pending composer keeps focus there once the session is created", async ({ page }) => {
|
||||
const mock = await openWorktreeDraft(page, pendingDraft)
|
||||
const pending = await submitPending(page, mock)
|
||||
await draftFollowUp(page)
|
||||
await pending.shimmer.click()
|
||||
await expect(editor(page)).not.toBeFocused()
|
||||
mock.worktree.resolve({ status: 200, json: { directory: workspace } })
|
||||
|
||||
await expect(page.locator("[data-session-title]").getByRole("heading", { level: 1 })).toHaveText(
|
||||
"Created workspace session",
|
||||
)
|
||||
await expect(pending.shimmer).toHaveCount(0)
|
||||
await expect(editor(page)).toHaveText(followUp)
|
||||
await expect(submit(page)).toBeEnabled()
|
||||
await expect(editor(page)).not.toBeFocused()
|
||||
await expect.poll(() => mock.calls).toEqual(["worktree", "session", "prompt"])
|
||||
await expect(editor(page)).not.toBeFocused()
|
||||
})
|
||||
|
||||
for (const row of [
|
||||
{ failure: "worktree", followUp: true, calls: ["worktree"] },
|
||||
{ failure: "session", followUp: true, calls: ["worktree", "session"] },
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { expect, test } from "bun:test"
|
||||
import { setCursorPosition } from "./dom"
|
||||
import { getCursorPosition, setCursorPosition } from "./dom"
|
||||
|
||||
const br = () => document.createElement("br")
|
||||
|
||||
@@ -51,7 +51,41 @@ test.each<{ name: string; nodes: () => Node[]; caret: [number, number | null, nu
|
||||
const selection = window.getSelection()
|
||||
expect(selection?.anchorNode).toBe(child === null ? container : container.childNodes[child]!)
|
||||
expect(selection?.anchorOffset).toBe(offset)
|
||||
expect(getCursorPosition(container)).toBe(position)
|
||||
})
|
||||
|
||||
container.remove()
|
||||
})
|
||||
|
||||
test("reads a caret on or inside a mention as before or after it", () => {
|
||||
const container = document.createElement("div")
|
||||
const mention = pill()
|
||||
container.append(text("ab"), mention, br(), text("cd"))
|
||||
document.body.appendChild(container)
|
||||
const selection = window.getSelection()!
|
||||
|
||||
selection.collapse(mention.firstChild, 0)
|
||||
expect(getCursorPosition(container)).toBe(2)
|
||||
selection.collapse(mention.firstChild, 3)
|
||||
expect(getCursorPosition(container)).toBe(7)
|
||||
selection.collapse(container.childNodes[2]!, 0)
|
||||
expect(getCursorPosition(container)).toBe(7)
|
||||
|
||||
container.remove()
|
||||
})
|
||||
|
||||
test("reads no caret for a range or a selection outside the editor", () => {
|
||||
const container = document.createElement("div")
|
||||
container.append(text("abcd"))
|
||||
const outside = text("outside")
|
||||
document.body.append(container, outside)
|
||||
const selection = window.getSelection()!
|
||||
|
||||
selection.setBaseAndExtent(container.firstChild!, 1, container.firstChild!, 3)
|
||||
expect(getCursorPosition(container)).toBeUndefined()
|
||||
selection.collapse(outside, 2)
|
||||
expect(getCursorPosition(container)).toBeUndefined()
|
||||
|
||||
container.remove()
|
||||
outside.remove()
|
||||
})
|
||||
|
||||
@@ -1,7 +1,52 @@
|
||||
function getNodeLength(node: Node): number {
|
||||
if (node.nodeType === Node.ELEMENT_NODE && (node as HTMLElement).tagName === "BR") return 1
|
||||
if (node instanceof Element && node.tagName === "BR") return 1
|
||||
|
||||
return (node.textContent ?? "").replace(/\u200B/g, "").length
|
||||
return textLength(node)
|
||||
}
|
||||
|
||||
// The node's text without zero-width spaces, like `textContent` but without building the string.
|
||||
function textLength(node: Node): number {
|
||||
if (node instanceof Text) return countText(node.data, node.length)
|
||||
let length = 0
|
||||
|
||||
for (let child = node.firstChild; child; child = child.nextSibling) length += textLength(child)
|
||||
|
||||
return length
|
||||
}
|
||||
|
||||
/**
|
||||
* The collapsed caret's position in `parent`, counted the way `setCursorPosition` places it, or `undefined` when
|
||||
* the selection is a range or lies outside `parent`. Runs on every `selectionchange`, so it allocates nothing.
|
||||
*/
|
||||
export function getCursorPosition(parent: HTMLElement) {
|
||||
const selection = window.getSelection()
|
||||
const anchor = selection?.anchorNode
|
||||
|
||||
if (!selection?.isCollapsed || !anchor || !parent.contains(anchor)) return
|
||||
const offset = selection.anchorOffset
|
||||
let position = 0
|
||||
let index = 0
|
||||
|
||||
for (let node = parent.firstChild; node; node = node.nextSibling) {
|
||||
if (anchor === parent && index === offset) return position
|
||||
|
||||
if (node === anchor && node instanceof Text) return position + countText(node.data, offset)
|
||||
|
||||
// Mentions and breaks are atomic: a caret on or inside one sits before or after it.
|
||||
if (node.contains(anchor)) return offset === 0 ? position : position + getNodeLength(node)
|
||||
position += getNodeLength(node)
|
||||
index++
|
||||
}
|
||||
|
||||
return position
|
||||
}
|
||||
|
||||
function countText(text: string, end: number) {
|
||||
let count = 0
|
||||
|
||||
for (let index = 0; index < end; index++) if (text.charCodeAt(index) !== 0x200b) count++
|
||||
|
||||
return count
|
||||
}
|
||||
|
||||
export function setCursorPosition(parent: HTMLElement, position: number) {
|
||||
@@ -11,8 +56,8 @@ export function setCursorPosition(parent: HTMLElement, position: number) {
|
||||
while (node) {
|
||||
const length = getNodeLength(node)
|
||||
const isText = node.nodeType === Node.TEXT_NODE
|
||||
const isPill = node.nodeType === Node.ELEMENT_NODE && !!(node as HTMLElement).dataset.mention
|
||||
const isBreak = node.nodeType === Node.ELEMENT_NODE && (node as HTMLElement).tagName === "BR"
|
||||
const isPill = node instanceof HTMLElement && !!node.dataset.mention
|
||||
const isBreak = node instanceof Element && node.tagName === "BR"
|
||||
|
||||
if (isText && remaining <= length) {
|
||||
const range = document.createRange()
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { createEffect, createMemo, on, onCleanup, type Accessor } from "solid-js"
|
||||
import { createEffect, createMemo, createSignal, on, onMount, untrack, type Accessor } from "solid-js"
|
||||
import { useDialog } from "@opencode/ui/context/dialog"
|
||||
import type { ComposerControls } from "@/composer/adapter"
|
||||
import { setCursorPosition } from "@/composer/editor/dom"
|
||||
@@ -6,6 +6,8 @@ import { promptLength } from "@/composer/prompt-parts"
|
||||
import { createComposerModel } from "@/composer/model"
|
||||
import { useSettings } from "@/settings/model"
|
||||
import { createActiveComposerAdapter } from "./adapter"
|
||||
import { useComposerFocus } from "./focus"
|
||||
import { needsRealComposerFocus } from "./focus-machine"
|
||||
import { createSessionQueue } from "./queue"
|
||||
import { createSessionComposerRegionController } from "./session-composer-region-controller"
|
||||
|
||||
@@ -17,8 +19,9 @@ export function createSessionComposerController(input: {
|
||||
}) {
|
||||
const settings = useSettings()
|
||||
const dialog = useDialog()
|
||||
const focus = useComposerFocus(input.sessionID)
|
||||
const region = createSessionComposerRegionController(input.dock)
|
||||
let editor: HTMLDivElement | undefined
|
||||
const [editor, setEditor] = createSignal<HTMLDivElement>()
|
||||
|
||||
const background = () => input.dock.state.background.steer(input.sessionID)
|
||||
|
||||
@@ -29,7 +32,7 @@ export function createSessionComposerController(input: {
|
||||
submitted: region.onResponseSubmit,
|
||||
background,
|
||||
setEditor: (element) => {
|
||||
editor = element
|
||||
setEditor(element)
|
||||
region.setPromptRef(element)
|
||||
},
|
||||
})
|
||||
@@ -41,7 +44,7 @@ export function createSessionComposerController(input: {
|
||||
behavior: settings.general.followUpBehavior,
|
||||
background,
|
||||
restoreFocus: (cursor) => {
|
||||
const target = editor
|
||||
const target = editor()
|
||||
|
||||
if (!target) return
|
||||
requestAnimationFrame(() => {
|
||||
@@ -52,33 +55,18 @@ export function createSessionComposerController(input: {
|
||||
})
|
||||
|
||||
const composer = createComposerModel(adapter, { queue })
|
||||
// This controller is recreated when a session becomes active. Wait for its draft and
|
||||
// the editor's DOM commit, without reacting to subsequent cursor or message updates.
|
||||
createEffect(
|
||||
on(adapter.ready, (ready) => {
|
||||
if (!ready) return
|
||||
|
||||
const frame = requestAnimationFrame(() => {
|
||||
if (!editor?.isConnected || !region.showComposer() || region.child() || dialog.active) return
|
||||
const active = document.activeElement
|
||||
|
||||
// A control chosen while the session was loading owns focus now. The tab link that opened the session
|
||||
// passes focus on, unless it sits in a dialog, such as the mobile tabs drawer reopened before the composer.
|
||||
if (
|
||||
active &&
|
||||
active !== document.body &&
|
||||
active !== editor &&
|
||||
(!active.matches("[data-titlebar-tab-link]") || active.closest('[role="dialog"]'))
|
||||
)
|
||||
return
|
||||
editor.focus({ preventScroll: true })
|
||||
setCursorPosition(editor, adapter.state.cursor() ?? promptLength(adapter.state.current()))
|
||||
})
|
||||
|
||||
onCleanup(() => cancelAnimationFrame(frame))
|
||||
}),
|
||||
)
|
||||
const editable = createMemo(() => region.showComposer() && !region.child())
|
||||
// This controller is recreated when a session becomes active, which is when its composer takes focus
|
||||
// (focus-machine.ts). It waits for the draft, the editor and any request dock or dialog to clear.
|
||||
focus.bindReal({ target: () => input.sessionID, element: editor, editable })
|
||||
onMount(() => focus.dispatch({ type: "real.mounted", target: input.sessionID }))
|
||||
createEffect(() => {
|
||||
if (!needsRealComposerFocus(focus.state(), input.sessionID)) return
|
||||
|
||||
if (!adapter.ready() || !editor() || !editable() || dialog.active) return
|
||||
const cursor = untrack(() => adapter.state.cursor() ?? promptLength(adapter.state.current()))
|
||||
focus.dispatch({ type: "real.ready", target: input.sessionID, cursor })
|
||||
})
|
||||
// Requests hide the view without disposing its draft or queue edit.
|
||||
createEffect(on(editable, () => composer.clearDrag()))
|
||||
|
||||
|
||||
@@ -0,0 +1,285 @@
|
||||
import { expect, test } from "bun:test"
|
||||
import {
|
||||
createComposerFocusState,
|
||||
FOCUS_HANDOFF_TIMEOUT_MS,
|
||||
needsRealComposerFocus,
|
||||
REAL_FOCUS_RETRY_LIMIT,
|
||||
transitionComposerFocus,
|
||||
type ComposerFocusEffect,
|
||||
type ComposerFocusEvent,
|
||||
type ComposerFocusState,
|
||||
} from "./focus-machine"
|
||||
|
||||
const A = "ses_a"
|
||||
|
||||
const B = "ses_b"
|
||||
|
||||
// A frame or timer result answers the state it was started from, the way the driver fences them by attempt.
|
||||
type Answer = { readonly answer: (state: ComposerFocusState) => ComposerFocusEvent }
|
||||
|
||||
type Step = ComposerFocusEvent | Answer
|
||||
|
||||
type Replay = {
|
||||
readonly state: ComposerFocusState
|
||||
readonly effects: readonly ComposerFocusEffect[]
|
||||
readonly log: readonly ComposerFocusEffect[]
|
||||
}
|
||||
|
||||
function replay(steps: Step[], initial = createComposerFocusState()) {
|
||||
const start: Replay = { state: initial, effects: [], log: [] }
|
||||
|
||||
return steps.reduce<Replay>((current, step) => {
|
||||
const result = transitionComposerFocus(current.state, "answer" in step ? step.answer(current.state) : step)
|
||||
|
||||
return { state: result.state, effects: result.effects, log: [...current.log, ...result.effects] }
|
||||
}, start)
|
||||
}
|
||||
|
||||
const attempt = (state: ComposerFocusState) => (state.status === "disposed" ? -1 : state.attempt)
|
||||
|
||||
const preparingFrame = (outcome: "focused" | "blocked"): Answer => ({
|
||||
answer: (state) => ({ type: "preparing.frame", attempt: attempt(state), outcome }),
|
||||
})
|
||||
|
||||
const realFrame = (outcome: "focused" | "claimed" | "blocked"): Answer => ({
|
||||
answer: (state) => ({ type: "real.frame", attempt: attempt(state), outcome }),
|
||||
})
|
||||
|
||||
const timeout: Answer = { answer: (state) => ({ type: "timeout", attempt: attempt(state) }) }
|
||||
|
||||
// The user typed in the pending session's composer, which took focus on its first frame.
|
||||
const typing: Step[] = [
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "preparing.mounted", target: A, cursor: 0 },
|
||||
preparingFrame("focused"),
|
||||
]
|
||||
|
||||
test("a session composer that mounts frames after the pending composer left takes its focus and caret", () => {
|
||||
const handoff = replay([...typing, { type: "preparing.unmounted", target: A, cursor: 32 }])
|
||||
expect(handoff.state).toMatchObject({ status: "handoff", target: A, cursor: 32 })
|
||||
expect(handoff.effects).toEqual([])
|
||||
|
||||
// The route resolves the session and the request dock clears before the composer can take focus.
|
||||
const mounted = replay([{ type: "real.mounted", target: A }], handoff.state)
|
||||
expect(mounted.state).toMatchObject({ status: "pending-real", cursor: 32, retries: 0 })
|
||||
expect(mounted.effects).toEqual([
|
||||
{ type: "timer.start", attempt: attempt(mounted.state), delayMs: FOCUS_HANDOFF_TIMEOUT_MS },
|
||||
])
|
||||
expect(needsRealComposerFocus(mounted.state, A)).toBe(true)
|
||||
|
||||
// The caret read from the pending editor wins over the stored cursor, which can lag behind it.
|
||||
const ready = replay([{ type: "real.ready", target: A, cursor: 31 }], mounted.state)
|
||||
expect(ready.effects).toEqual([
|
||||
{ type: "timer.clear" },
|
||||
{ type: "frame.real", target: A, attempt: attempt(ready.state), cursor: 32 },
|
||||
])
|
||||
|
||||
const done = replay([realFrame("focused")], ready.state)
|
||||
expect(done.state).toMatchObject({ status: "idle", target: A })
|
||||
expect(needsRealComposerFocus(done.state, A)).toBe(false)
|
||||
})
|
||||
|
||||
test("a session created before the pending composer's first frame still hands focus over", () => {
|
||||
const claiming = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "preparing.mounted", target: A, cursor: 4 },
|
||||
])
|
||||
|
||||
expect(claiming.effects).toEqual([{ type: "frame.preparing", target: A, attempt: attempt(claiming.state), cursor: 4 }])
|
||||
const late = preparingFrame("focused").answer(claiming.state)
|
||||
|
||||
const handoff = replay([{ type: "preparing.unmounted", target: A, cursor: 4 }], claiming.state)
|
||||
expect(handoff.state).toMatchObject({ status: "handoff", cursor: 4 })
|
||||
expect(handoff.effects).toEqual([{ type: "frame.cancel" }])
|
||||
expect(transitionComposerFocus(handoff.state, late).state).toBe(handoff.state)
|
||||
})
|
||||
|
||||
test("a user who left the pending composer keeps focus when the session composer replaces it", () => {
|
||||
const declined = replay([
|
||||
...typing,
|
||||
{ type: "preparing.blurred", target: A },
|
||||
{ type: "preparing.unmounted", target: A, cursor: 4 },
|
||||
])
|
||||
|
||||
expect(declined.state).toMatchObject({ status: "declined", target: A })
|
||||
|
||||
const mounted = replay([{ type: "real.mounted", target: A }], declined.state)
|
||||
expect(mounted.state).toMatchObject({ status: "idle", target: A })
|
||||
expect(mounted.effects).toEqual([])
|
||||
expect(needsRealComposerFocus(mounted.state, A)).toBe(false)
|
||||
expect(transitionComposerFocus(mounted.state, { type: "real.ready", target: A, cursor: 4 }).state).toBe(mounted.state)
|
||||
|
||||
// Coming back to the session later opens it as usual.
|
||||
const revisit = replay(
|
||||
[
|
||||
{ type: "target.changed", target: B },
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "real.mounted", target: A },
|
||||
],
|
||||
mounted.state,
|
||||
)
|
||||
|
||||
expect(revisit.state).toMatchObject({ status: "pending-real", target: A, cursor: undefined })
|
||||
})
|
||||
|
||||
test("a control or dialog that holds focus on the pending composer's first frame counts as leaving it", () => {
|
||||
const blocked = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "preparing.mounted", target: A, cursor: 0 },
|
||||
preparingFrame("blocked"),
|
||||
{ type: "preparing.unmounted", target: A, cursor: 0 },
|
||||
])
|
||||
|
||||
expect(blocked.state).toMatchObject({ status: "declined" })
|
||||
})
|
||||
|
||||
test("returning to the pending composer before the session is created hands focus over again", () => {
|
||||
const result = replay([
|
||||
...typing,
|
||||
{ type: "preparing.blurred", target: A },
|
||||
{ type: "preparing.focused", target: A },
|
||||
{ type: "preparing.unmounted", target: A, cursor: 7 },
|
||||
])
|
||||
|
||||
expect(result.state).toMatchObject({ status: "handoff", cursor: 7 })
|
||||
})
|
||||
|
||||
test("focusing the pending composer before its first frame cancels the frame", () => {
|
||||
const result = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "preparing.mounted", target: A, cursor: 0 },
|
||||
{ type: "preparing.focused", target: A },
|
||||
])
|
||||
|
||||
expect(result.state).toMatchObject({ status: "preparing", focus: "focused" })
|
||||
expect(result.effects).toEqual([{ type: "frame.cancel" }])
|
||||
})
|
||||
|
||||
test("opening a session focuses its composer at the stored caret", () => {
|
||||
const result = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "real.mounted", target: A },
|
||||
{ type: "real.ready", target: A, cursor: 5 },
|
||||
])
|
||||
|
||||
expect(result.effects).toEqual([
|
||||
{ type: "timer.clear" },
|
||||
{ type: "frame.real", target: A, attempt: attempt(result.state), cursor: 5 },
|
||||
])
|
||||
|
||||
const claimed = replay([realFrame("claimed")], result.state)
|
||||
expect(claimed.state).toMatchObject({ status: "idle", target: A })
|
||||
|
||||
// A remounted composer, such as after the mobile changes view, focuses again.
|
||||
const remounted = replay([{ type: "real.mounted", target: A }], claimed.state)
|
||||
expect(remounted.state).toMatchObject({ status: "pending-real", target: A })
|
||||
})
|
||||
|
||||
test("a composer hidden again before its frame waits again, up to the retry limit", () => {
|
||||
const ready: Step[] = [{ type: "real.ready", target: A, cursor: 3 }]
|
||||
|
||||
const opened = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "real.mounted", target: A },
|
||||
...ready,
|
||||
])
|
||||
|
||||
const retried = Array.from({ length: REAL_FOCUS_RETRY_LIMIT }).reduce<ComposerFocusState>((state, _, index) => {
|
||||
const result = replay([realFrame("blocked")], state)
|
||||
expect(result.state).toMatchObject({ status: "pending-real", cursor: 3, retries: index + 1 })
|
||||
expect(result.effects).toEqual([
|
||||
{ type: "timer.start", attempt: attempt(result.state), delayMs: FOCUS_HANDOFF_TIMEOUT_MS },
|
||||
])
|
||||
|
||||
return replay(ready, result.state).state
|
||||
}, opened.state)
|
||||
|
||||
const result = replay([realFrame("blocked")], retried)
|
||||
expect(result.state).toMatchObject({ status: "idle", target: A })
|
||||
expect(result.effects).toEqual([])
|
||||
})
|
||||
|
||||
test("a composer that never becomes focusable gives up at the timeout, ignoring stale timers", () => {
|
||||
const waiting = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "real.mounted", target: A },
|
||||
])
|
||||
|
||||
const stale = transitionComposerFocus(waiting.state, { type: "timeout", attempt: attempt(waiting.state) - 1 })
|
||||
expect(stale.state).toBe(waiting.state)
|
||||
|
||||
const result = replay([timeout], waiting.state)
|
||||
expect(result.state).toMatchObject({ status: "idle", target: A })
|
||||
expect(transitionComposerFocus(result.state, { type: "real.ready", target: A, cursor: 0 }).state).toBe(result.state)
|
||||
})
|
||||
|
||||
test("stale frames from an earlier phase are ignored", () => {
|
||||
const opened = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "real.mounted", target: A },
|
||||
{ type: "real.ready", target: A, cursor: 0 },
|
||||
])
|
||||
|
||||
const late = realFrame("focused").answer(opened.state)
|
||||
const again = replay([realFrame("blocked"), { type: "real.ready", target: A, cursor: 0 }], opened.state)
|
||||
expect(again.state).toMatchObject({ status: "focusing-real" })
|
||||
expect(transitionComposerFocus(again.state, late).state).toBe(again.state)
|
||||
})
|
||||
|
||||
test("switching sessions cancels the previous session's frame and timer and ignores its late events", () => {
|
||||
const claiming = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "preparing.mounted", target: A, cursor: 0 },
|
||||
])
|
||||
|
||||
const late = preparingFrame("focused").answer(claiming.state)
|
||||
|
||||
const switched = replay([{ type: "target.changed", target: B }], claiming.state)
|
||||
expect(switched.state).toMatchObject({ status: "idle", target: B })
|
||||
expect(switched.effects).toEqual([{ type: "frame.cancel" }])
|
||||
const after = replay([late, { type: "preparing.unmounted", target: A, cursor: 0 }], switched.state)
|
||||
expect(after.state).toBe(switched.state)
|
||||
|
||||
const waiting = replay([{ type: "real.mounted", target: B }], switched.state)
|
||||
expect(replay([{ type: "target.changed", target: A }], waiting.state).effects).toEqual([{ type: "timer.clear" }])
|
||||
|
||||
// The pending composer may unmount before or after the route reports the new session.
|
||||
const unmountedFirst = replay(
|
||||
[
|
||||
{ type: "preparing.unmounted", target: A, cursor: 0 },
|
||||
{ type: "target.changed", target: B },
|
||||
{ type: "real.mounted", target: B },
|
||||
],
|
||||
claiming.state,
|
||||
)
|
||||
|
||||
expect(unmountedFirst.state).toMatchObject({ status: "pending-real", target: B, cursor: undefined })
|
||||
})
|
||||
|
||||
test("disposal cancels pending work and ignores every later event", () => {
|
||||
const waiting = replay([
|
||||
{ type: "target.changed", target: A },
|
||||
{ type: "real.mounted", target: A },
|
||||
])
|
||||
|
||||
expect(replay([{ type: "disposed" }], waiting.state).effects).toEqual([{ type: "timer.clear" }])
|
||||
|
||||
const focusing = replay([{ type: "real.ready", target: A, cursor: 0 }], waiting.state)
|
||||
const disposed = replay([{ type: "disposed" }], focusing.state)
|
||||
expect(disposed.effects).toEqual([{ type: "frame.cancel" }])
|
||||
|
||||
const later = replay(
|
||||
[
|
||||
{ type: "target.changed", target: B },
|
||||
{ type: "real.mounted", target: B },
|
||||
],
|
||||
disposed.state,
|
||||
)
|
||||
|
||||
expect(later.state).toBe(disposed.state)
|
||||
expect(later.log).toEqual([])
|
||||
})
|
||||
|
||||
test("each machine starts from its own state", () => {
|
||||
expect(createComposerFocusState()).not.toBe(createComposerFocusState())
|
||||
})
|
||||
@@ -0,0 +1,212 @@
|
||||
// How long a mounted session composer may wait to become focusable (draft loaded, no request dock or dialog)
|
||||
// before it stops trying to take focus.
|
||||
export const FOCUS_HANDOFF_TIMEOUT_MS = 10_000
|
||||
|
||||
// Frames that found the composer gone or hidden after it looked ready, before the attempt gives up.
|
||||
export const REAL_FOCUS_RETRY_LIMIT = 3
|
||||
|
||||
export type PreparingFocus = "claiming" | "focused" | "blurred"
|
||||
|
||||
// Focus for the routed session, across the pending session's composer and the session composer that replaces it.
|
||||
// `target` is the routed session ID; the machine lives under one server, so the ID alone names the session.
|
||||
// `attempt` advances on every phase change, so a late frame or timer from an earlier phase is ignored.
|
||||
//
|
||||
// - `idle`: nothing to do until a session composer mounts, which then takes focus (opening a session).
|
||||
// - `preparing`: the pending session's composer is shown. `claiming` is its first focus frame in flight.
|
||||
// - `handoff`: the pending composer unmounted while it held focus; the session composer takes focus and `cursor` when it mounts.
|
||||
// - `declined`: the user had left the pending composer; the session composer that replaces it leaves focus alone.
|
||||
// - `pending-real`: the session composer is mounted and waits until it can take focus.
|
||||
// - `focusing-real`: its focus frame is in flight.
|
||||
export type ComposerFocusState =
|
||||
| { readonly status: "idle"; readonly target: string | undefined; readonly attempt: number }
|
||||
| { readonly status: "preparing"; readonly target: string; readonly attempt: number; readonly focus: PreparingFocus }
|
||||
| { readonly status: "handoff"; readonly target: string; readonly attempt: number; readonly cursor: number }
|
||||
| { readonly status: "declined"; readonly target: string; readonly attempt: number }
|
||||
| {
|
||||
readonly status: "pending-real"
|
||||
readonly target: string
|
||||
readonly attempt: number
|
||||
readonly cursor: number | undefined
|
||||
readonly retries: number
|
||||
}
|
||||
| {
|
||||
readonly status: "focusing-real"
|
||||
readonly target: string
|
||||
readonly attempt: number
|
||||
readonly cursor: number
|
||||
readonly retries: number
|
||||
}
|
||||
| { readonly status: "disposed" }
|
||||
|
||||
export type ComposerFocusEvent =
|
||||
| { readonly type: "target.changed"; readonly target: string }
|
||||
| { readonly type: "preparing.mounted"; readonly target: string; readonly cursor: number }
|
||||
| { readonly type: "preparing.frame"; readonly attempt: number; readonly outcome: "focused" | "blocked" }
|
||||
| { readonly type: "preparing.focused"; readonly target: string }
|
||||
| { readonly type: "preparing.blurred"; readonly target: string }
|
||||
| { readonly type: "preparing.unmounted"; readonly target: string; readonly cursor: number }
|
||||
| { readonly type: "real.mounted"; readonly target: string }
|
||||
| { readonly type: "real.ready"; readonly target: string; readonly cursor: number }
|
||||
| { readonly type: "real.frame"; readonly attempt: number; readonly outcome: "focused" | "claimed" | "blocked" }
|
||||
| { readonly type: "timeout"; readonly attempt: number }
|
||||
| { readonly type: "disposed" }
|
||||
|
||||
export type ComposerFocusEffect =
|
||||
| { readonly type: "frame.preparing"; readonly target: string; readonly attempt: number; readonly cursor: number }
|
||||
| { readonly type: "frame.real"; readonly target: string; readonly attempt: number; readonly cursor: number }
|
||||
| { readonly type: "frame.cancel" }
|
||||
| { readonly type: "timer.start"; readonly attempt: number; readonly delayMs: number }
|
||||
| { readonly type: "timer.clear" }
|
||||
|
||||
export type ComposerFocusTransition = {
|
||||
readonly state: ComposerFocusState
|
||||
readonly effects: readonly ComposerFocusEffect[]
|
||||
}
|
||||
|
||||
type Active = Exclude<ComposerFocusState, { readonly status: "disposed" }>
|
||||
|
||||
const NO_EFFECTS: readonly ComposerFocusEffect[] = []
|
||||
|
||||
export function createComposerFocusState(): ComposerFocusState {
|
||||
return { status: "idle", target: undefined, attempt: 0 }
|
||||
}
|
||||
|
||||
export function transitionComposerFocus(state: ComposerFocusState, event: ComposerFocusEvent): ComposerFocusTransition {
|
||||
if (state.status === "disposed") return unchanged(state)
|
||||
|
||||
if (event.type === "disposed") return { state: { status: "disposed" }, effects: cleanup(state) }
|
||||
|
||||
if (event.type === "target.changed") {
|
||||
if (event.target === state.target) return unchanged(state)
|
||||
|
||||
return { state: { status: "idle", target: event.target, attempt: state.attempt + 1 }, effects: cleanup(state) }
|
||||
}
|
||||
|
||||
if (event.type === "preparing.frame") return preparingFrame(state, event)
|
||||
|
||||
if (event.type === "real.frame") return realFrame(state, event)
|
||||
|
||||
if (event.type === "timeout") {
|
||||
if (state.status !== "pending-real" || state.attempt !== event.attempt) return unchanged(state)
|
||||
|
||||
return changed({ status: "idle", target: state.target, attempt: state.attempt })
|
||||
}
|
||||
|
||||
if (event.target !== state.target) return unchanged(state)
|
||||
const target = event.target
|
||||
const attempt = state.attempt + 1
|
||||
|
||||
if (event.type === "preparing.mounted") {
|
||||
return changed({ status: "preparing", target, attempt, focus: "claiming" }, [
|
||||
...cleanup(state),
|
||||
{ type: "frame.preparing", target, attempt, cursor: event.cursor },
|
||||
])
|
||||
}
|
||||
|
||||
if (event.type === "real.mounted") return realMounted(state, target)
|
||||
|
||||
if (event.type === "real.ready") {
|
||||
if (state.status !== "pending-real") return unchanged(state)
|
||||
const cursor = state.cursor ?? event.cursor
|
||||
|
||||
return changed({ status: "focusing-real", target, attempt, cursor, retries: state.retries }, [
|
||||
{ type: "timer.clear" },
|
||||
{ type: "frame.real", target, attempt, cursor },
|
||||
])
|
||||
}
|
||||
|
||||
if (state.status !== "preparing") return unchanged(state)
|
||||
|
||||
if (event.type === "preparing.unmounted") {
|
||||
// A user who left the composer while the session was created keeps focus where they put it.
|
||||
if (state.focus === "blurred") return changed({ status: "declined", target, attempt }, cleanup(state))
|
||||
|
||||
// Claiming counts as focused: a session created before the first frame still hands focus over.
|
||||
return changed({ status: "handoff", target, attempt, cursor: event.cursor }, cleanup(state))
|
||||
}
|
||||
|
||||
const focus = event.type === "preparing.focused" ? "focused" : "blurred"
|
||||
|
||||
if (state.focus === focus) return unchanged(state)
|
||||
|
||||
return changed({ ...state, focus }, cleanup(state))
|
||||
}
|
||||
|
||||
/** Whether the session composer for `target` is waiting to take focus. */
|
||||
export function needsRealComposerFocus(state: ComposerFocusState, target: string) {
|
||||
return state.status === "pending-real" && state.target === target
|
||||
}
|
||||
|
||||
function preparingFrame(
|
||||
state: Active,
|
||||
event: Extract<ComposerFocusEvent, { readonly type: "preparing.frame" }>,
|
||||
): ComposerFocusTransition {
|
||||
if (state.status !== "preparing" || state.focus !== "claiming" || state.attempt !== event.attempt) {
|
||||
return unchanged(state)
|
||||
}
|
||||
|
||||
// Another control or a dialog held focus, so the user is elsewhere.
|
||||
return changed({ ...state, focus: event.outcome === "focused" ? "focused" : "blurred" })
|
||||
}
|
||||
|
||||
function realFrame(
|
||||
state: Active,
|
||||
event: Extract<ComposerFocusEvent, { readonly type: "real.frame" }>,
|
||||
): ComposerFocusTransition {
|
||||
if (state.status !== "focusing-real" || state.attempt !== event.attempt) return unchanged(state)
|
||||
|
||||
// The composer became ready, then disappeared or a dialog opened before the frame: wait for it again.
|
||||
if (event.outcome === "blocked" && state.retries < REAL_FOCUS_RETRY_LIMIT) {
|
||||
const attempt = state.attempt + 1
|
||||
|
||||
return changed(
|
||||
{
|
||||
status: "pending-real",
|
||||
target: state.target,
|
||||
attempt,
|
||||
cursor: state.cursor,
|
||||
retries: state.retries + 1,
|
||||
},
|
||||
[{ type: "timer.start", attempt, delayMs: FOCUS_HANDOFF_TIMEOUT_MS }],
|
||||
)
|
||||
}
|
||||
|
||||
return changed({ status: "idle", target: state.target, attempt: state.attempt })
|
||||
}
|
||||
|
||||
function realMounted(state: Active, target: string): ComposerFocusTransition {
|
||||
const attempt = state.attempt + 1
|
||||
|
||||
if (state.status === "declined") return changed({ status: "idle", target, attempt })
|
||||
|
||||
if (state.status !== "idle" && state.status !== "handoff") return unchanged(state)
|
||||
|
||||
return changed(
|
||||
{
|
||||
status: "pending-real",
|
||||
target,
|
||||
attempt,
|
||||
cursor: state.status === "handoff" ? state.cursor : undefined,
|
||||
retries: 0,
|
||||
},
|
||||
[{ type: "timer.start", attempt, delayMs: FOCUS_HANDOFF_TIMEOUT_MS }],
|
||||
)
|
||||
}
|
||||
|
||||
function cleanup(state: Active): readonly ComposerFocusEffect[] {
|
||||
if ((state.status === "preparing" && state.focus === "claiming") || state.status === "focusing-real") {
|
||||
return [{ type: "frame.cancel" }]
|
||||
}
|
||||
|
||||
if (state.status === "pending-real") return [{ type: "timer.clear" }]
|
||||
|
||||
return NO_EFFECTS
|
||||
}
|
||||
|
||||
function changed(state: ComposerFocusState, effects = NO_EFFECTS): ComposerFocusTransition {
|
||||
return { state, effects }
|
||||
}
|
||||
|
||||
function unchanged(state: ComposerFocusState): ComposerFocusTransition {
|
||||
return { state, effects: NO_EFFECTS }
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
import {
|
||||
createComputed,
|
||||
createContext,
|
||||
createSignal,
|
||||
onCleanup,
|
||||
untrack,
|
||||
useContext,
|
||||
type Accessor,
|
||||
type ParentProps,
|
||||
} from "solid-js"
|
||||
import { useDialog } from "@opencode/ui/context/dialog"
|
||||
import { setCursorPosition } from "@/composer/editor/dom"
|
||||
import {
|
||||
createComposerFocusState,
|
||||
transitionComposerFocus,
|
||||
type ComposerFocusEffect,
|
||||
type ComposerFocusEvent,
|
||||
} from "./focus-machine"
|
||||
|
||||
// A composer that can take focus for one session: the pending session's composer or the session composer.
|
||||
type ComposerSurface = {
|
||||
target: Accessor<string>
|
||||
element: Accessor<HTMLElement | undefined>
|
||||
editable?: Accessor<boolean>
|
||||
}
|
||||
|
||||
export type ComposerFocus = ReturnType<typeof createComposerFocus>
|
||||
|
||||
const ComposerFocusContext = createContext<ComposerFocus>()
|
||||
|
||||
// One machine for the session route, so focus outlives the pending composer until the session composer mounts.
|
||||
export function ComposerFocusProvider(props: ParentProps<{ sessionID: string }>) {
|
||||
const focus = createComposerFocus()
|
||||
|
||||
// A computation, not an effect: the target changes before the new session's composers mount and report to it.
|
||||
createComputed(() => focus.dispatch({ type: "target.changed", target: props.sessionID }))
|
||||
|
||||
return <ComposerFocusContext.Provider value={focus}>{props.children}</ComposerFocusContext.Provider>
|
||||
}
|
||||
|
||||
// Outside the session route (stories), a session composer focuses itself as it does when a session opens.
|
||||
export function useComposerFocus(sessionID: string) {
|
||||
const routed = useContext(ComposerFocusContext)
|
||||
|
||||
if (routed) return routed
|
||||
const focus = createComposerFocus()
|
||||
focus.dispatch({ type: "target.changed", target: sessionID })
|
||||
|
||||
return focus
|
||||
}
|
||||
|
||||
// The tab link that opened the session passes focus on, unless it sits in a dialog, such as the mobile tabs drawer
|
||||
// reopened before the composer.
|
||||
export function isTitlebarTabLink(element: Element) {
|
||||
return element.matches("[data-titlebar-tab-link]") && !element.closest('[role="dialog"]')
|
||||
}
|
||||
|
||||
function createComposerFocus() {
|
||||
const dialog = useDialog()
|
||||
const [state, setState] = createSignal(createComposerFocusState())
|
||||
let frame: number | undefined
|
||||
let timer: ReturnType<typeof setTimeout> | undefined
|
||||
let preparing: ComposerSurface | undefined
|
||||
let real: ComposerSurface | undefined
|
||||
|
||||
const dispatch = (event: ComposerFocusEvent) => {
|
||||
const previous = untrack(state)
|
||||
const result = transitionComposerFocus(previous, event)
|
||||
|
||||
if (result.state === previous) return
|
||||
setState(result.state)
|
||||
result.effects.forEach(run)
|
||||
}
|
||||
|
||||
const run = (effect: ComposerFocusEffect) => {
|
||||
if (effect.type === "frame.cancel") return cancelFrame()
|
||||
|
||||
if (effect.type === "timer.clear") return clearTimer()
|
||||
|
||||
if (effect.type === "timer.start") {
|
||||
clearTimer()
|
||||
timer = setTimeout(() => {
|
||||
timer = undefined
|
||||
dispatch({ type: "timeout", attempt: effect.attempt })
|
||||
}, effect.delayMs)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
cancelFrame()
|
||||
// One frame after mounting, so the editor's content and the outgoing composer's DOM have settled.
|
||||
frame = requestAnimationFrame(() => {
|
||||
frame = undefined
|
||||
|
||||
if (effect.type === "frame.real") {
|
||||
dispatch({ type: "real.frame", attempt: effect.attempt, outcome: focusSurface(real, effect) })
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
const outcome = focusSurface(preparing, effect) === "focused" ? "focused" : "blocked"
|
||||
dispatch({ type: "preparing.frame", attempt: effect.attempt, outcome })
|
||||
})
|
||||
}
|
||||
|
||||
const focusSurface = (
|
||||
surface: ComposerSurface | undefined,
|
||||
effect: { target: string; cursor: number },
|
||||
): "focused" | "claimed" | "blocked" => {
|
||||
const element = surface?.target() === effect.target ? surface.element() : undefined
|
||||
|
||||
if (!element?.isConnected || surface?.editable?.() === false || dialog.active) return "blocked"
|
||||
const active = document.activeElement
|
||||
|
||||
// The user already put the caret in this composer.
|
||||
if (active && element.contains(active)) return "focused"
|
||||
|
||||
// A control chosen while the session was loading owns focus now.
|
||||
if (active && active !== document.body && !isTitlebarTabLink(active)) return "claimed"
|
||||
element.focus({ preventScroll: true })
|
||||
setCursorPosition(element, effect.cursor)
|
||||
|
||||
return "focused"
|
||||
}
|
||||
|
||||
const cancelFrame = () => {
|
||||
if (frame === undefined) return
|
||||
cancelAnimationFrame(frame)
|
||||
frame = undefined
|
||||
}
|
||||
|
||||
const clearTimer = () => {
|
||||
if (timer === undefined) return
|
||||
clearTimeout(timer)
|
||||
timer = undefined
|
||||
}
|
||||
|
||||
onCleanup(() => dispatch({ type: "disposed" }))
|
||||
|
||||
return {
|
||||
state,
|
||||
dispatch,
|
||||
bindPreparing(surface: ComposerSurface) {
|
||||
preparing = surface
|
||||
onCleanup(() => {
|
||||
if (preparing === surface) preparing = undefined
|
||||
})
|
||||
},
|
||||
bindReal(surface: ComposerSurface) {
|
||||
real = surface
|
||||
onCleanup(() => {
|
||||
if (real === surface) real = undefined
|
||||
})
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -1,45 +1,62 @@
|
||||
import { createEffect, on, onCleanup } from "solid-js"
|
||||
import { useLocation } from "@solidjs/router"
|
||||
import { createEffect, createSignal, on, onCleanup } from "solid-js"
|
||||
import { makeEventListener } from "@solid-primitives/event-listener"
|
||||
import { ComposerEditor } from "@/composer/editor/editor"
|
||||
import { setCursorPosition } from "@/composer/editor/dom"
|
||||
import { getCursorPosition } from "@/composer/editor/dom"
|
||||
import { createComposerEditor } from "@/composer/editor/interaction"
|
||||
import { promptLength } from "@/composer/prompt-parts"
|
||||
import type { PendingSession } from "@/shell/tabs/tabs"
|
||||
import { isTitlebarTabLink, useComposerFocus } from "./composer/focus"
|
||||
|
||||
export function PreparingComposer(props: { pending: PendingSession }) {
|
||||
const location = useLocation()
|
||||
let element: HTMLElement | undefined
|
||||
export function PreparingComposer(props: { sessionID: string; pending: PendingSession }) {
|
||||
const focus = useComposerFocus(props.sessionID)
|
||||
const [element, setElement] = createSignal<HTMLElement>()
|
||||
|
||||
const editor = createComposerEditor({
|
||||
store: () => props.pending.composer.store,
|
||||
commands: () => [],
|
||||
context: () => [],
|
||||
searchContextFiles: () => [],
|
||||
onEditor: (value) => {
|
||||
element = value
|
||||
},
|
||||
onEditor: setElement,
|
||||
view: {
|
||||
draftOnly: true,
|
||||
submit: { stopping: () => false, onSubmit() {}, onStop() {} },
|
||||
},
|
||||
})
|
||||
|
||||
focus.bindPreparing({ target: () => props.sessionID, element })
|
||||
|
||||
createEffect(() => {
|
||||
const el = element()
|
||||
|
||||
if (!el) return
|
||||
makeEventListener(el, "focusin", () => focus.dispatch({ type: "preparing.focused", target: props.sessionID }))
|
||||
makeEventListener(el, "focusout", (event) => {
|
||||
// Removing the editor, or the window losing focus, is not the user leaving it.
|
||||
if (!el.isConnected || !document.hasFocus() || document.activeElement === el) return
|
||||
|
||||
if (event.relatedTarget instanceof Element && isTitlebarTabLink(event.relatedTarget)) return
|
||||
focus.dispatch({ type: "preparing.blurred", target: props.sessionID })
|
||||
})
|
||||
// The editor stores the caret only on input, key up and pointer up. Keep it current while a key is held, so
|
||||
// the draft that moves into the created session carries the caret.
|
||||
makeEventListener(document, "selectionchange", () => {
|
||||
if (document.activeElement !== el) return
|
||||
const cursor = getCursorPosition(el)
|
||||
|
||||
if (cursor !== undefined && cursor !== props.pending.composer.cursor()) editor.onCursor(cursor)
|
||||
})
|
||||
})
|
||||
|
||||
createEffect(
|
||||
on(
|
||||
() => props.pending,
|
||||
(pending) => {
|
||||
const pathname = location.pathname
|
||||
editor.restoreFocus(pending.composer.cursor())
|
||||
const target = props.sessionID
|
||||
const cursor = () => pending.composer.cursor() ?? promptLength(pending.composer.current())
|
||||
focus.dispatch({ type: "preparing.mounted", target, cursor: cursor() })
|
||||
onCleanup(() => {
|
||||
if (document.activeElement !== element) return
|
||||
const cursor = pending.composer.cursor()
|
||||
requestAnimationFrame(() => {
|
||||
if (location.pathname !== pathname) return
|
||||
const next = document.querySelector<HTMLDivElement>('[data-component="composer-editor"]')
|
||||
|
||||
if (!next || next === element) return
|
||||
next.focus()
|
||||
setCursorPosition(next, cursor ?? 0)
|
||||
})
|
||||
const el = element()
|
||||
focus.dispatch({ type: "preparing.unmounted", target, cursor: (el && getCursorPosition(el)) ?? cursor() })
|
||||
})
|
||||
},
|
||||
),
|
||||
|
||||
@@ -33,6 +33,7 @@ import { sessionRouteView } from "./resolution-machine"
|
||||
import { createSessionResolution } from "./session-resolution"
|
||||
import { SessionScreenView } from "./screen"
|
||||
import { PreparingComposer } from "./preparing-composer"
|
||||
import { ComposerFocusProvider } from "./composer/focus"
|
||||
|
||||
export function TargetSessionRouteContent() {
|
||||
const params = useParams<{ serverKey: string; id: string }>()
|
||||
@@ -48,9 +49,11 @@ export function TargetSessionRouteContent() {
|
||||
<ModelsProvider directory={directory()}>
|
||||
<TargetSessionSettingsCommand />
|
||||
<SessionRouteErrorBoundary sessionID={params.id} serverKey={requireServerKey(params.serverKey)}>
|
||||
<Show when={tabs.pendingSession(server.key, params.id)} fallback={<ResolvedTargetSessionRoute />}>
|
||||
{(pending) => <PreparingSession sessionID={params.id} pending={pending()} />}
|
||||
</Show>
|
||||
<ComposerFocusProvider sessionID={params.id}>
|
||||
<Show when={tabs.pendingSession(server.key, params.id)} fallback={<ResolvedTargetSessionRoute />}>
|
||||
{(pending) => <PreparingSession sessionID={params.id} pending={pending()} />}
|
||||
</Show>
|
||||
</ComposerFocusProvider>
|
||||
</SessionRouteErrorBoundary>
|
||||
</ModelsProvider>
|
||||
</>
|
||||
@@ -96,7 +99,7 @@ function PreparingSession(props: { sessionID: string; pending: PendingSession })
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<PreparingComposer pending={props.pending} />
|
||||
<PreparingComposer sessionID={props.sessionID} pending={props.pending} />
|
||||
</DataProvider>
|
||||
</SessionStatePanel>
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user