From 2ec64857375142a038623c16d29fe71cf1821a8e Mon Sep 17 00:00:00 2001 From: Luke Parker <10430890+Hona@users.noreply.github.com> Date: Thu, 5 Nov 2026 01:28:44 -0600 Subject: [PATCH] fix(app): make tab preview, crash page actions, notification focus lock and mobile tabs drawer explicit state machines (#62005) --- packages/app/src/shell/errors/error.tsx | 238 ++++++++++++------ packages/app/src/shell/errors/machine.test.ts | 178 +++++++++++++ packages/app/src/shell/errors/machine.ts | 217 ++++++++++++++++ .../src/shell/notifications/coordinator.ts | 74 +++--- .../notifications/focus-lock-machine.test.ts | 79 ++++++ .../shell/notifications/focus-lock-machine.ts | 76 ++++++ .../titlebar/mobile-tabs-machine.test.ts | 105 ++++++++ .../src/shell/titlebar/mobile-tabs-machine.ts | 102 ++++++++ .../titlebar/tab-popover-machine.test.ts | 132 ++++++++++ .../src/shell/titlebar/tab-popover-machine.ts | 139 ++++++++++ .../app/src/shell/titlebar/tab-popover.tsx | 218 ++++++++-------- packages/app/src/shell/titlebar/titlebar.tsx | 63 +++-- 12 files changed, 1379 insertions(+), 242 deletions(-) create mode 100644 packages/app/src/shell/errors/machine.test.ts create mode 100644 packages/app/src/shell/errors/machine.ts create mode 100644 packages/app/src/shell/notifications/focus-lock-machine.test.ts create mode 100644 packages/app/src/shell/notifications/focus-lock-machine.ts create mode 100644 packages/app/src/shell/titlebar/mobile-tabs-machine.test.ts create mode 100644 packages/app/src/shell/titlebar/mobile-tabs-machine.ts create mode 100644 packages/app/src/shell/titlebar/tab-popover-machine.test.ts create mode 100644 packages/app/src/shell/titlebar/tab-popover-machine.ts diff --git a/packages/app/src/shell/errors/error.tsx b/packages/app/src/shell/errors/error.tsx index ee381c49a66..176b01cbdab 100644 --- a/packages/app/src/shell/errors/error.tsx +++ b/packages/app/src/shell/errors/error.tsx @@ -2,8 +2,7 @@ import { TextField } from "@opencode/ui/text-field" import type { captureException } from "@sentry/solid" import { Logo } from "@opencode/ui/logo" import { Button } from "@opencode/ui/button" -import { Component, createSignal, onCleanup, onMount, Show } from "solid-js" -import { createStore } from "solid-js/store" +import { Component, createEffect, createSignal, on, onCleanup, onMount, Show, untrack } from "solid-js" import { Predicate } from "effect" import { Updater } from "@opencode/plugin/gui/updater" import { usePlatform } from "@/runtime/platform/platform" @@ -11,6 +10,22 @@ import { useLanguage } from "@/runtime/i18n/language" import { createIpcClients } from "@/runtime/plugin/ipc" import { Icon } from "@opencode/ui/icon" import { errorDescriptionKey, errorStatus } from "./description" +import { + INITIAL_ERROR_PAGE_STATE, + isUpdaterBusy, + selectActionError, + selectCanReport, + selectCheckingUpdates, + selectCheckUpdatesDisabled, + selectExportDisabled, + selectInstallUpdateDisabled, + selectReportDisabled, + selectReported, + selectUpdateVersion, + transitionErrorPage, + type ErrorPageEffect, + type ErrorPageEvent, +} from "./machine" type InitError = { name: unknown @@ -257,75 +272,132 @@ export const ErrorPage: Component = (props) => { const language = useLanguage() const formattedError = () => formatError(props.error, language.t) const status = () => errorStatus(props.error) - let recordedFatalError: Promise | undefined + const [pageState, setPageState] = createSignal(INITIAL_ERROR_PAGE_STATE) + let capture: typeof captureException | undefined + // The crash record in flight, which Export Logs waits for instead of recording the crash twice. + let recording: Promise | undefined + const timers = new Set>() - const [store, setStore] = createStore<{ - actionError: string | undefined - captureException: typeof captureException | undefined - }>({ - actionError: undefined, - captureException: undefined, - }) + // A crash can take the plugin root down with the app, so the page reaches the updater's + // main-process Ipc over the bridge itself. + const ipcs = createIpcClients(platform.plugins) + const updater = () => ipcs.typed(Updater) - function ensureFatalErrorRecorded() { - recordedFatalError ??= + const dispatch = (event: ErrorPageEvent) => { + const previous = untrack(pageState) + const next = transitionErrorPage(previous, event) + + if (next.state !== previous) setPageState(next.state) + next.effects.forEach(run) + } + + function run(effect: ErrorPageEffect) { + if (effect.type === "sentry.capture") return capture?.(props.error) + + if (effect.type === "fatal.record") { + const attempt = effect.attempt + void record(attempt) + later(effect.timeoutMs, () => dispatch({ type: "fatal.settled", attempt, recorded: false })) + + return + } + + const attempt = effect.attempt + + // Each action resolves to its error message, or undefined when it succeeded. + const settle = (work: Promise) => + void work.then( + (error) => + dispatch( + error === undefined ? { type: "action.succeeded", attempt } : { type: "action.failed", attempt, error }, + ), + (cause) => dispatch({ type: "action.failed", attempt, error: formatError(cause, language.t) }), + ) + + if (effect.type === "logs.export") { + const recorded = effect.recordFirst ? (recording ?? record(effect.fatalAttempt)) : Promise.resolve(true) + + // A crash that cannot be recorded still leaves the logs to export; the native save dialog has no time limit. + return settle( + within(recorded, effect.recordTimeoutMs) + .then(() => platform.exportDebugLogs?.()) + .then(() => undefined), + ) + } + + later(effect.timeoutMs, () => + dispatch({ type: "action.timed-out", attempt, error: language.t("common.requestFailed") }), + ) + + if (effect.type === "updater.install") return settle(Promise.try(() => updater()?.install()).then(() => undefined)) + + settle( + Promise.try(() => updater()?.check()).then((state) => (state?.status === "error" ? state.message : undefined)), + ) + } + + function record(attempt: number) { + const pending = Promise.try(() => platform.recordFatalRendererError?.({ error: formattedError(), url: location.href, version: platform.version, platform: platform.platform, os: platform.os, - }) ?? Promise.resolve() + }), + ).then( + () => true, + () => false, + ) - return recordedFatalError + recording = pending + void pending.then((recorded) => { + if (recording === pending) recording = undefined + dispatch({ type: "fatal.settled", attempt, recorded }) + }) + + return pending } + function later(ms: number, fn: () => void) { + const timer = setTimeout(() => { + timers.delete(timer) + fn() + }, ms) + + timers.add(timer) + } + + function within(promise: Promise, ms: number) { + return new Promise((resolve) => { + later(ms, resolve) + void promise.then(() => resolve()) + }) + } + + createEffect( + on( + () => props.error, + () => dispatch({ type: "error.presented" }), + ), + ) + onMount(() => { - void ensureFatalErrorRecorded().catch(() => undefined) void import("@sentry/solid") .then(({ captureException, isEnabled }) => { - if (isEnabled()) setStore("captureException", () => captureException) + const enabled = isEnabled() + + if (enabled) capture = captureException + dispatch({ type: "sentry.loaded", enabled }) }) .catch(() => undefined) }) - // A crash can take the plugin root down with the app, so the page reaches the updater's - // main-process Ipc over the bridge itself. - const ipcs = createIpcClients(platform.plugins) - onCleanup(ipcs.dispose) - const updater = () => ipcs.typed(Updater) - - async function checkForUpdates() { - const state = await updater()?.check() - setStore("actionError", state?.status === "error" ? state.message : undefined) - } - - async function installUpdate() { - await updater() - ?.install() - .then(() => setStore("actionError", undefined)) - .catch((err) => { - setStore("actionError", formatError(err, language.t)) - }) - } - - const updateVersion = () => { - const state = updater()?.state() - - return state?.status === "ready" || state?.status === "download-required" ? state.version : undefined - } - - async function exportDebugLogs() { - const exportLogs = platform.exportDebugLogs - - if (!exportLogs) return - await ensureFatalErrorRecorded() - .then(() => exportLogs()) - .then(() => setStore("actionError", undefined)) - .catch((err) => { - setStore("actionError", formatError(err, language.t)) - }) - } + onCleanup(() => { + ipcs.dispose() + timers.forEach(clearTimeout) + dispatch({ type: "disposed" }) + }) return (
= (props) => { {language.t(platform.platform === "web" ? "error.page.action.reload" : "error.page.action.restart")} - - - {(capture) => { - const [reported, setReported] = createSignal(false) - - return ( - - ) - }} + + + dispatch({ + type: "check.clicked", + available: !!updater(), + busy: isUpdaterBusy(updater()?.state()), + }) + } + disabled={selectCheckUpdatesDisabled(pageState(), updater()?.state())} > - {updater()?.state()?.status === "checking" + {selectCheckingUpdates(pageState(), updater()?.state()) ? language.t("error.page.action.checking") : language.t("error.page.action.checkUpdates")} } > {(version) => ( - )}
- + {(message) =>

{message()}

}
diff --git a/packages/app/src/shell/errors/machine.test.ts b/packages/app/src/shell/errors/machine.test.ts new file mode 100644 index 00000000000..28641e2cb84 --- /dev/null +++ b/packages/app/src/shell/errors/machine.test.ts @@ -0,0 +1,178 @@ +import { describe, expect, test } from "bun:test" +import { + ERROR_ACTION_TIMEOUT_MS, + FATAL_RECORD_TIMEOUT_MS, + INITIAL_ERROR_PAGE_STATE, + selectActionError, + selectCheckUpdatesDisabled, + selectExportDisabled, + selectInstallUpdateDisabled, + selectReportDisabled, + selectReported, + transitionErrorPage, + type ErrorPageEffect, + type ErrorPageEvent, + type ErrorPageState, +} from "./machine" + +const replay = (events: ErrorPageEvent[], state = INITIAL_ERROR_PAGE_STATE) => + events.reduce<{ state: ErrorPageState; effects: ErrorPageEffect[] }>( + (current, event) => { + const next = transitionErrorPage(current.state, event) + + return { state: next.state, effects: [...current.effects, ...next.effects] } + }, + { state, effects: [] }, + ) + +const presented: ErrorPageEvent = { type: "error.presented" } + +const check: ErrorPageEvent = { type: "check.clicked", available: true, busy: false } + +const install: ErrorPageEvent = { type: "install.clicked", available: true, busy: false } + +const exportLogs: ErrorPageEvent = { type: "export.clicked", available: true } + +describe("error page actions", () => { + test("starting an action clears the previous action's error", () => { + const failed = replay([presented, exportLogs, { type: "action.failed", attempt: 1, error: "Export failed" }]).state + expect(selectActionError(failed)).toBe("Export failed") + + const checking = transitionErrorPage(failed, check) + expect(checking.state.status).toBe("checking") + expect(selectActionError(checking.state)).toBeUndefined() + expect(checking.effects).toEqual([{ type: "updater.check", attempt: 2, timeoutMs: ERROR_ACTION_TIMEOUT_MS }]) + }) + + test("a crash that failed to record does not block Export Logs", () => { + const start = replay([presented]) + expect(start.effects).toEqual([{ type: "fatal.record", attempt: 1, timeoutMs: FATAL_RECORD_TIMEOUT_MS }]) + + const unrecorded = transitionErrorPage(start.state, { type: "fatal.settled", attempt: 1, recorded: false }).state + const exporting = transitionErrorPage(unrecorded, exportLogs) + expect(exporting.effects).toEqual([ + { + type: "logs.export", + attempt: 1, + fatalAttempt: 1, + recordFirst: true, + recordTimeoutMs: FATAL_RECORD_TIMEOUT_MS, + }, + ]) + expect(transitionErrorPage(exporting.state, { type: "action.succeeded", attempt: 1 }).state.status).toBe("idle") + }) + + test("a recorded crash exports at once, even when the record answered after its timeout", () => { + const late = replay([ + presented, + { type: "fatal.settled", attempt: 1, recorded: false }, + { type: "fatal.settled", attempt: 1, recorded: true }, + exportLogs, + ]) + + expect(late.effects.at(-1)).toMatchObject({ type: "logs.export", recordFirst: false }) + }) + + test("the first click claims the action and later clicks wait", () => { + const exporting = replay([presented, exportLogs]).state + expect(selectExportDisabled(exporting)).toBe(true) + expect(selectCheckUpdatesDisabled(exporting, undefined)).toBe(true) + + for (const event of [exportLogs, install, check]) { + const again = transitionErrorPage(exporting, event) + expect(again.state).toBe(exporting) + expect(again.effects).toEqual([]) + } + }) + + test("results of an earlier action are ignored", () => { + const installing = replay([presented, check, { type: "action.succeeded", attempt: 1 }, install]).state + expect(installing).toMatchObject({ status: "installing", attempt: 2 }) + + for (const event of [ + { type: "action.succeeded", attempt: 1 }, + { type: "action.failed", attempt: 1, error: "late" }, + { type: "action.timed-out", attempt: 1, error: "late" }, + ] satisfies ErrorPageEvent[]) + expect(transitionErrorPage(installing, event).state).toBe(installing) + }) + + test("a busy or missing updater does not start an action", () => { + const idle = replay([presented]).state + expect(transitionErrorPage(idle, { type: "check.clicked", available: true, busy: true }).state).toBe(idle) + expect(transitionErrorPage(idle, { type: "install.clicked", available: false, busy: false }).state).toBe(idle) + expect(transitionErrorPage(idle, { type: "export.clicked", available: false }).state).toBe(idle) + }) + + test("a check that never answers fails after the timeout and can be retried", () => { + const timedOut = replay([presented, check, { type: "action.timed-out", attempt: 1, error: "Request failed" }]) + expect(selectActionError(timedOut.state)).toBe("Request failed") + expect(selectCheckUpdatesDisabled(timedOut.state, undefined)).toBe(false) + expect(transitionErrorPage(timedOut.state, check).state.status).toBe("checking") + }) + + test("a new error resets the report and the action error, and records the new crash", () => { + const reported = replay([ + presented, + { type: "sentry.loaded", enabled: true }, + { type: "report.clicked" }, + check, + { type: "action.failed", attempt: 1, error: "Check failed" }, + ]) + + expect(reported.effects).toContainEqual({ type: "sentry.capture" }) + expect(selectReported(reported.state)).toBe(true) + expect(selectReportDisabled(reported.state)).toBe(true) + + const next = transitionErrorPage(reported.state, presented) + expect(next.state).toEqual({ status: "idle", attempt: 1, fatalAttempt: 2, fatal: "recording", report: "ready" }) + expect(selectActionError(next.state)).toBeUndefined() + expect(next.effects).toEqual([{ type: "fatal.record", attempt: 2, timeoutMs: FATAL_RECORD_TIMEOUT_MS }]) + // The previous crash's record answers late. + expect(transitionErrorPage(next.state, { type: "fatal.settled", attempt: 1, recorded: true }).state).toBe( + next.state, + ) + }) + + test("an action still running when a new error arrives keeps the page busy until it settles", () => { + for (const start of [check, install, exportLogs]) { + const busy = replay([presented, { type: "sentry.loaded", enabled: true }, { type: "report.clicked" }, start]) + const next = transitionErrorPage(busy.state, presented) + + expect(next.state).toMatchObject({ status: busy.state.status, attempt: 1, fatalAttempt: 2, report: "ready" }) + expect(selectExportDisabled(next.state)).toBe(true) + expect(selectCheckUpdatesDisabled(next.state, undefined)).toBe(true) + expect(selectInstallUpdateDisabled(next.state, undefined)).toBe(true) + + // A click meanwhile does not start a second action beside the first. + for (const event of [check, install, exportLogs]) + expect(transitionErrorPage(next.state, event).state).toBe(next.state) + + // The running action settles; its timeout and late duplicates then change nothing. + const failed = transitionErrorPage(next.state, { type: "action.failed", attempt: 1, error: "Install failed" }) + expect(selectActionError(failed.state)).toBe("Install failed") + expect(transitionErrorPage(failed.state, { type: "action.timed-out", attempt: 1, error: "late" }).state).toBe( + failed.state, + ) + expect( + transitionErrorPage(next.state, { type: "action.timed-out", attempt: 1, error: "Request failed" }).state, + ).toMatchObject({ status: "failed", error: "Request failed" }) + } + }) + + test("Report stays hidden until Sentry is enabled, and sends once", () => { + const idle = replay([presented, { type: "sentry.loaded", enabled: false }]).state + expect(transitionErrorPage(idle, { type: "report.clicked" }).effects).toEqual([]) + + const reported = replay([{ type: "sentry.loaded", enabled: true }, { type: "report.clicked" }], idle).state + expect(transitionErrorPage(reported, { type: "report.clicked" }).effects).toEqual([]) + }) + + test("disposal ignores every later event", () => { + const disposed = replay([presented, check, { type: "disposed" }]).state + expect(disposed.status).toBe("disposed") + + for (const event of [{ type: "action.succeeded", attempt: 2 }, presented, exportLogs] satisfies ErrorPageEvent[]) + expect(transitionErrorPage(disposed, event).state).toBe(disposed) + }) +}) diff --git a/packages/app/src/shell/errors/machine.ts b/packages/app/src/shell/errors/machine.ts new file mode 100644 index 00000000000..082291a3adf --- /dev/null +++ b/packages/app/src/shell/errors/machine.ts @@ -0,0 +1,217 @@ +import type { UpdaterState } from "@opencode/plugin/gui/updater" + +// Main bounds its own update check; this covers a bridge that never answers after the crash. +export const ERROR_ACTION_TIMEOUT_MS = 30_000 + +// Export Logs waits this long for the crash to reach the log before it exports anyway. +export const FATAL_RECORD_TIMEOUT_MS = 2_000 + +/** Whether the crash reached the main-process log: `pending` until it has, so Export Logs records it first. */ +export type ErrorFatalStatus = "pending" | "recording" | "recorded" + +/** `unavailable` while Sentry is off or still loading; `reported` once the user sent this error. */ +export type ErrorReportStatus = "unavailable" | "ready" | "reported" + +type ErrorPageFields = { + readonly attempt: number + readonly fatalAttempt: number + readonly fatal: ErrorFatalStatus + readonly report: ErrorReportStatus +} + +/** + * The crash page's actions. One action runs at a time; `failed` shows its error until the next action starts or + * another error is shown. + */ +export type ErrorPageState = + | (ErrorPageFields & { readonly status: "idle" }) + | (ErrorPageFields & { readonly status: "checking" }) + | (ErrorPageFields & { readonly status: "installing" }) + | (ErrorPageFields & { readonly status: "exporting" }) + | (ErrorPageFields & { readonly status: "failed"; readonly error: string }) + | { readonly status: "disposed" } + +export type ErrorPageEvent = + /** The page shows an error: on mount, and again when the boundary passes a new one. */ + | { readonly type: "error.presented" } + | { readonly type: "fatal.settled"; readonly attempt: number; readonly recorded: boolean } + | { readonly type: "sentry.loaded"; readonly enabled: boolean } + | { readonly type: "report.clicked" } + /** `available` is false without an updater; `busy` while the updater itself checks, downloads or installs. */ + | { readonly type: "check.clicked"; readonly available: boolean; readonly busy: boolean } + | { readonly type: "install.clicked"; readonly available: boolean; readonly busy: boolean } + | { readonly type: "export.clicked"; readonly available: boolean } + | { readonly type: "action.succeeded"; readonly attempt: number } + | { readonly type: "action.failed"; readonly attempt: number; readonly error: string } + | { readonly type: "action.timed-out"; readonly attempt: number; readonly error: string } + | { readonly type: "disposed" } + +export type ErrorPageEffect = + | { readonly type: "fatal.record"; readonly attempt: number; readonly timeoutMs: number } + | { readonly type: "sentry.capture" } + | { readonly type: "updater.check"; readonly attempt: number; readonly timeoutMs: number } + | { readonly type: "updater.install"; readonly attempt: number; readonly timeoutMs: number } + /** `recordFirst` records the crash first, bounded by `recordTimeoutMs`, so the exported log holds it. */ + | { + readonly type: "logs.export" + readonly attempt: number + readonly fatalAttempt: number + readonly recordFirst: boolean + readonly recordTimeoutMs: number + } + +export type ErrorPageTransition = { + readonly state: ErrorPageState + readonly effects: readonly ErrorPageEffect[] +} + +export const INITIAL_ERROR_PAGE_STATE: ErrorPageState = Object.freeze({ + status: "idle", + attempt: 0, + fatalAttempt: 0, + fatal: "pending", + report: "unavailable", +}) + +const DISPOSED: ErrorPageState = Object.freeze({ status: "disposed" }) + +const NONE: readonly ErrorPageEffect[] = [] + +export function transitionErrorPage(state: ErrorPageState, event: ErrorPageEvent): ErrorPageTransition { + if (state.status === "disposed") return unchanged(state) + + if (event.type === "disposed") return { state: DISPOSED, effects: NONE } + + if (event.type === "error.presented") { + // A new error gets its own record and report, and drops the previous action's error. An action still running + // stays busy until it settles: it acts on the app, not on the error, and a second one must not start beside it. + const attempt = state.fatalAttempt + 1 + + return { + state: { + status: state.status === "failed" ? "idle" : state.status, + attempt: state.attempt, + fatalAttempt: attempt, + fatal: "recording", + report: state.report === "unavailable" ? "unavailable" : "ready", + }, + effects: [{ type: "fatal.record", attempt, timeoutMs: FATAL_RECORD_TIMEOUT_MS }], + } + } + + if (event.type === "fatal.settled") { + if (event.attempt !== state.fatalAttempt || state.fatal === "recorded") return unchanged(state) + // A record that answers after its timeout still counts, so Export Logs does not record it twice. + const fatal = event.recorded ? "recorded" : "pending" + + return fatal === state.fatal ? unchanged(state) : { state: { ...state, fatal }, effects: NONE } + } + + if (event.type === "sentry.loaded") + return event.enabled && state.report === "unavailable" + ? { state: { ...state, report: "ready" }, effects: NONE } + : unchanged(state) + + if (event.type === "report.clicked") + return state.report === "ready" + ? { state: { ...state, report: "reported" }, effects: [{ type: "sentry.capture" }] } + : unchanged(state) + + if (event.type === "check.clicked" || event.type === "install.clicked" || event.type === "export.clicked") + return start(state, event) + + if (!isBusy(state) || event.attempt !== state.attempt) return unchanged(state) + + if (event.type === "action.succeeded") return { state: { ...fields(state), status: "idle" }, effects: NONE } + + return { state: { ...fields(state), status: "failed", error: event.error }, effects: NONE } +} + +export function selectCanReport(state: ErrorPageState) { + return state.status !== "disposed" && state.report !== "unavailable" +} + +export function selectReported(state: ErrorPageState) { + return state.status !== "disposed" && state.report === "reported" +} + +export function selectReportDisabled(state: ErrorPageState) { + return state.status === "disposed" || state.report !== "ready" +} + +export function selectExportDisabled(state: ErrorPageState) { + return state.status === "disposed" || isBusy(state) +} + +export function selectUpdateVersion(updater: UpdaterState | undefined) { + return updater?.status === "ready" || updater?.status === "download-required" ? updater.version : undefined +} + +export function selectCheckingUpdates(state: ErrorPageState, updater: UpdaterState | undefined) { + return state.status === "checking" || updater?.status === "checking" +} + +export function selectCheckUpdatesDisabled(state: ErrorPageState, updater: UpdaterState | undefined) { + return state.status === "disposed" || isBusy(state) || isUpdaterBusy(updater) +} + +export function selectInstallUpdateDisabled(state: ErrorPageState, updater: UpdaterState | undefined) { + return state.status === "disposed" || isBusy(state) || updater?.status === "installing" +} + +export function selectActionError(state: ErrorPageState) { + return state.status === "failed" ? state.error : undefined +} + +export function isUpdaterBusy(updater: UpdaterState | undefined) { + return updater?.status === "checking" || updater?.status === "downloading" || updater?.status === "installing" +} + +type LiveState = Exclude + +function start( + state: LiveState, + event: Extract, +): ErrorPageTransition { + // The first click claims the action; a double click, or another action meanwhile, waits for it. + if (isBusy(state) || !event.available || (event.type !== "export.clicked" && event.busy)) return unchanged(state) + const attempt = state.attempt + 1 + const next = { ...fields(state), attempt } + + if (event.type === "check.clicked") + return { + state: { ...next, status: "checking" }, + effects: [{ type: "updater.check", attempt, timeoutMs: ERROR_ACTION_TIMEOUT_MS }], + } + + if (event.type === "install.clicked") + return { + state: { ...next, status: "installing" }, + effects: [{ type: "updater.install", attempt, timeoutMs: ERROR_ACTION_TIMEOUT_MS }], + } + + return { + state: { ...next, status: "exporting" }, + effects: [ + { + type: "logs.export", + attempt, + fatalAttempt: state.fatalAttempt, + recordFirst: state.fatal !== "recorded", + recordTimeoutMs: FATAL_RECORD_TIMEOUT_MS, + }, + ], + } +} + +function isBusy(state: ErrorPageState) { + return state.status === "checking" || state.status === "installing" || state.status === "exporting" +} + +function fields(state: LiveState): ErrorPageFields { + return { attempt: state.attempt, fatalAttempt: state.fatalAttempt, fatal: state.fatal, report: state.report } +} + +function unchanged(state: ErrorPageState): ErrorPageTransition { + return { state, effects: NONE } +} diff --git a/packages/app/src/shell/notifications/coordinator.ts b/packages/app/src/shell/notifications/coordinator.ts index 5449356c0e9..66d5494f20f 100644 --- a/packages/app/src/shell/notifications/coordinator.ts +++ b/packages/app/src/shell/notifications/coordinator.ts @@ -1,7 +1,6 @@ import { onCleanup } from "solid-js" import { Predicate } from "effect" - -type FocusLock = { pending: boolean; release?: VoidFunction } +import { INITIAL_FOCUS_LOCK_STATE, transitionFocusLock, type FocusLockEvent } from "./focus-lock-machine" const FOCUS_LOCK = "opencode:notification-focus" @@ -14,43 +13,52 @@ export function createNotificationCoordinator() { const claimed = new Set() - const focus: FocusLock = { pending: false } + if (typeof window !== "undefined" && locks) { + let focusState = INITIAL_FOCUS_LOCK_STATE + const releases = new Map() - const updateFocus = () => { - if (typeof document === "undefined" || !document.hasFocus()) { - focus.release?.() + const dispatch = (event: FocusLockEvent) => { + const next = transitionFocusLock(focusState, event) + focusState = next.state + next.effects.forEach((effect) => { + const attempt = effect.attempt - return + if (effect.type === "lock.release") { + releases.get(attempt)?.() + releases.delete(attempt) + + return + } + + // A shared hold: every focused window keeps it, and an alert's exclusive request fails while any one does. + locks + .request( + FOCUS_LOCK, + { mode: "shared" }, + () => + new Promise((resolve) => { + releases.set(attempt, resolve) + dispatch({ type: "lock.acquired", attempt }) + }), + ) + .catch(() => { + releases.delete(attempt) + dispatch({ type: "lock.failed", attempt }) + }) + }) } - if (!locks || focus.pending || focus.release) return + const syncFocus = () => dispatch({ type: "focus.changed", focused: document.hasFocus() }) - focus.pending = true - void locks - .request(FOCUS_LOCK, { mode: "shared" }, async () => { - focus.pending = false - - if (!document.hasFocus()) return - await new Promise((resolve) => { - focus.release = resolve - }) - focus.release = undefined - }) - .catch(() => { - focus.pending = false - }) - } - - if (typeof window !== "undefined") { - window.addEventListener("focus", updateFocus) - window.addEventListener("blur", updateFocus) - document.addEventListener("visibilitychange", updateFocus) - updateFocus() + window.addEventListener("focus", syncFocus) + window.addEventListener("blur", syncFocus) + document.addEventListener("visibilitychange", syncFocus) + syncFocus() onCleanup(() => { - window.removeEventListener("focus", updateFocus) - window.removeEventListener("blur", updateFocus) - document.removeEventListener("visibilitychange", updateFocus) - focus.release?.() + window.removeEventListener("focus", syncFocus) + window.removeEventListener("blur", syncFocus) + document.removeEventListener("visibilitychange", syncFocus) + dispatch({ type: "disposed" }) }) } diff --git a/packages/app/src/shell/notifications/focus-lock-machine.test.ts b/packages/app/src/shell/notifications/focus-lock-machine.test.ts new file mode 100644 index 00000000000..3a7d1b6ab6c --- /dev/null +++ b/packages/app/src/shell/notifications/focus-lock-machine.test.ts @@ -0,0 +1,79 @@ +import { describe, expect, test } from "bun:test" +import { + INITIAL_FOCUS_LOCK_STATE, + transitionFocusLock, + type FocusLockEffect, + type FocusLockEvent, + type FocusLockState, +} from "./focus-lock-machine" + +const replay = (events: FocusLockEvent[], state = INITIAL_FOCUS_LOCK_STATE) => + events.reduce<{ state: FocusLockState; effects: FocusLockEffect[] }>( + (current, event) => { + const next = transitionFocusLock(current.state, event) + + return { state: next.state, effects: [...current.effects, ...next.effects] } + }, + { state, effects: [] }, + ) + +const focus = (focused: boolean): FocusLockEvent => ({ type: "focus.changed", focused }) + +describe("notification focus lock", () => { + test("a blur and an immediate refocus request the lock again", () => { + const held = replay([focus(true), { type: "lock.acquired", attempt: 1 }]).state + expect(held).toEqual({ status: "held", attempt: 1 }) + + // Both events land before the released lock callback resumes. + const result = replay([focus(false), focus(true)], held) + expect(result.effects).toEqual([ + { type: "lock.release", attempt: 1 }, + { type: "lock.acquire", attempt: 2 }, + ]) + expect(result.state).toEqual({ status: "requesting", attempt: 2, focused: true }) + expect(replay([{ type: "lock.acquired", attempt: 2 }], result.state).state).toEqual({ status: "held", attempt: 2 }) + }) + + test("a grant after disposal is released", () => { + const disposed = replay([focus(true), { type: "disposed" }]) + expect(disposed.state.status).toBe("disposed") + expect(disposed.effects).toEqual([{ type: "lock.acquire", attempt: 1 }]) + + const late = transitionFocusLock(disposed.state, { type: "lock.acquired", attempt: 1 }) + expect(late.state).toBe(disposed.state) + expect(late.effects).toEqual([{ type: "lock.release", attempt: 1 }]) + }) + + test("disposing while held releases the lock", () => { + const result = replay([focus(true), { type: "lock.acquired", attempt: 1 }, { type: "disposed" }]) + expect(result.effects.at(-1)).toEqual({ type: "lock.release", attempt: 1 }) + expect(transitionFocusLock(result.state, focus(true)).effects).toEqual([]) + }) + + test("focus changes while requesting do not request twice", () => { + const flicker = replay([focus(true), focus(false), focus(true)]) + expect(flicker.effects).toEqual([{ type: "lock.acquire", attempt: 1 }]) + expect(replay([{ type: "lock.acquired", attempt: 1 }], flicker.state).state).toEqual({ status: "held", attempt: 1 }) + + // Still unfocused when the grant arrives: release it at once. + const blurred = replay([focus(true), focus(false), { type: "lock.acquired", attempt: 1 }]) + expect(blurred.state).toEqual({ status: "unfocused", attempt: 1 }) + expect(blurred.effects.at(-1)).toEqual({ type: "lock.release", attempt: 1 }) + }) + + test("a failed request lets the next focus try again", () => { + const failed = replay([focus(true), { type: "lock.failed", attempt: 1 }]) + expect(failed.state).toEqual({ status: "unfocused", attempt: 1 }) + expect(transitionFocusLock(failed.state, focus(true)).effects).toEqual([{ type: "lock.acquire", attempt: 2 }]) + }) + + test("a stale grant is released and a stale failure is ignored", () => { + const requesting = replay([focus(true), focus(false), focus(true)]).state + const held = replay([{ type: "lock.acquired", attempt: 1 }], requesting).state + const stale = transitionFocusLock(held, { type: "lock.acquired", attempt: 0 }) + expect(stale.state).toBe(held) + expect(stale.effects).toEqual([{ type: "lock.release", attempt: 0 }]) + expect(transitionFocusLock(held, { type: "lock.failed", attempt: 0 }).state).toBe(held) + expect(transitionFocusLock(held, focus(true)).state).toBe(held) + }) +}) diff --git a/packages/app/src/shell/notifications/focus-lock-machine.ts b/packages/app/src/shell/notifications/focus-lock-machine.ts new file mode 100644 index 00000000000..f6001746e26 --- /dev/null +++ b/packages/app/src/shell/notifications/focus-lock-machine.ts @@ -0,0 +1,76 @@ +/** + * The shared Web Lock a focused window holds so other windows skip system notifications. `requesting` waits for the + * grant and tracks focus meanwhile; a grant that arrives after the window lost focus is released at once. + */ +export type FocusLockState = + | { readonly status: "unfocused"; readonly attempt: number } + | { readonly status: "requesting"; readonly attempt: number; readonly focused: boolean } + | { readonly status: "held"; readonly attempt: number } + | { readonly status: "disposed" } + +export type FocusLockEvent = + | { readonly type: "focus.changed"; readonly focused: boolean } + | { readonly type: "lock.acquired"; readonly attempt: number } + | { readonly type: "lock.failed"; readonly attempt: number } + | { readonly type: "disposed" } + +export type FocusLockEffect = + | { readonly type: "lock.acquire"; readonly attempt: number } + | { readonly type: "lock.release"; readonly attempt: number } + +export type FocusLockTransition = { + readonly state: FocusLockState + readonly effects: readonly FocusLockEffect[] +} + +export const INITIAL_FOCUS_LOCK_STATE: FocusLockState = Object.freeze({ status: "unfocused", attempt: 0 }) + +const DISPOSED: FocusLockState = Object.freeze({ status: "disposed" }) + +const NONE: readonly FocusLockEffect[] = [] + +export function transitionFocusLock(state: FocusLockState, event: FocusLockEvent): FocusLockTransition { + // Every grant nobody wants is released, or the lock would be held until the window closes. + const release: readonly FocusLockEffect[] = + event.type === "lock.acquired" ? [{ type: "lock.release", attempt: event.attempt }] : NONE + + if (state.status === "disposed") return { state, effects: release } + + if (event.type === "disposed") + return { + state: DISPOSED, + effects: state.status === "held" ? [{ type: "lock.release", attempt: state.attempt }] : NONE, + } + + if (event.type === "focus.changed") { + if (state.status === "unfocused") { + if (!event.focused) return unchanged(state) + const attempt = state.attempt + 1 + + return { state: { status: "requesting", attempt, focused: true }, effects: [{ type: "lock.acquire", attempt }] } + } + + if (state.status === "requesting") + return state.focused === event.focused + ? unchanged(state) + : { state: { ...state, focused: event.focused }, effects: NONE } + + if (event.focused) return unchanged(state) + + return { + state: { status: "unfocused", attempt: state.attempt }, + effects: [{ type: "lock.release", attempt: state.attempt }], + } + } + + if (state.status !== "requesting" || state.attempt !== event.attempt) return { state, effects: release } + + if (event.type === "lock.failed" || !state.focused) + return { state: { status: "unfocused", attempt: state.attempt }, effects: release } + + return { state: { status: "held", attempt: state.attempt }, effects: NONE } +} + +function unchanged(state: FocusLockState): FocusLockTransition { + return { state, effects: NONE } +} diff --git a/packages/app/src/shell/titlebar/mobile-tabs-machine.test.ts b/packages/app/src/shell/titlebar/mobile-tabs-machine.test.ts new file mode 100644 index 00000000000..40145982d32 --- /dev/null +++ b/packages/app/src/shell/titlebar/mobile-tabs-machine.test.ts @@ -0,0 +1,105 @@ +import { describe, expect, test } from "bun:test" +import { + INITIAL_MOBILE_TABS_STATE, + MOBILE_TABS_CLOSE_TIMEOUT_MS, + selectMobileTabsOpen, + transitionMobileTabs, + type MobileTabsEffect, + type MobileTabsEvent, + type MobileTabsState, +} from "./mobile-tabs-machine" + +const replay = (events: MobileTabsEvent[], state = INITIAL_MOBILE_TABS_STATE) => + events.reduce<{ state: MobileTabsState; effects: MobileTabsEffect[] }>( + (current, event) => { + const next = transitionMobileTabs(current.state, event) + + return { state: next.state, effects: [...current.effects, ...next.effects] } + }, + { state, effects: [] }, + ) + +const opened: MobileTabsEvent = { type: "drawer.changed", open: true } + +const closedByDrawer: MobileTabsEvent = { type: "drawer.changed", open: false } + +const gone: MobileTabsEvent = { type: "content.present", present: false } + +const settings: MobileTabsEvent = { type: "settings.requested" } + +const opensSettings = (effects: MobileTabsEffect[]) => + effects.filter((effect) => effect.type === "settings.open").length + +describe("mobile tabs drawer", () => { + test("Settings opens once the drawer has slid out", () => { + const closing = replay([opened, settings]) + expect(closing.state).toEqual({ status: "closing-to-settings", attempt: 1 }) + expect(closing.effects).toEqual([{ type: "timer.start", attempt: 1, timeoutMs: MOBILE_TABS_CLOSE_TIMEOUT_MS }]) + expect(selectMobileTabsOpen(closing.state)).toBe(false) + + // The drawer may report its own close while it slides out; Settings still waits for the end. + const echoed = transitionMobileTabs(closing.state, closedByDrawer) + expect(echoed.state).toBe(closing.state) + + const done = transitionMobileTabs(closing.state, gone) + expect(done.state).toEqual({ status: "closed", attempt: 1 }) + expect(done.effects).toEqual([{ type: "timer.clear" }, { type: "settings.open" }]) + }) + + test("reopening the drawer mid-close cancels Settings", () => { + const result = replay([opened, settings, opened, closedByDrawer, gone]) + expect(result.effects).toContainEqual({ type: "timer.clear" }) + expect(opensSettings(result.effects)).toBe(0) + expect(result.state.status).toBe("closed") + }) + + test("picking a tab or navigating mid-close cancels Settings", () => { + for (const cancel of [{ type: "close" }, { type: "route.changed" }] satisfies MobileTabsEvent[]) { + const result = replay([opened, settings, cancel, gone, { type: "close.timed-out", attempt: 1 }]) + expect(result.state.status).toBe("closed") + expect(opensSettings(result.effects)).toBe(0) + } + }) + + test("leaving the phone layout mid-close opens Settings at once", () => { + const result = replay([opened, settings, { type: "viewport.changed", mobile: false }, gone]) + expect(result.state.status).toBe("closed") + expect(opensSettings(result.effects)).toBe(1) + }) + + test("an exit that never ends opens Settings after the timeout, once", () => { + const result = replay([opened, settings, { type: "close.timed-out", attempt: 1 }, gone]) + expect(opensSettings(result.effects)).toBe(1) + + // A later, unrelated close does not open Settings. + expect(opensSettings(replay([opened, closedByDrawer, gone], result.state).effects)).toBe(0) + }) + + test("a timeout from an earlier Settings request is ignored", () => { + const closing = replay([opened, settings, opened, settings]).state + expect(closing).toEqual({ status: "closing-to-settings", attempt: 2 }) + expect(transitionMobileTabs(closing, { type: "close.timed-out", attempt: 1 }).state).toBe(closing) + }) + + test("route and viewport changes close an open drawer", () => { + for (const event of [ + { type: "route.changed" }, + { type: "viewport.changed", mobile: false }, + ] satisfies MobileTabsEvent[]) { + const result = replay([opened, event]) + expect(result.state).toEqual({ status: "closed", attempt: 0 }) + expect(result.effects).toEqual([]) + } + + const open = replay([opened]).state + expect(transitionMobileTabs(open, { type: "viewport.changed", mobile: true }).state).toBe(open) + expect(transitionMobileTabs(INITIAL_MOBILE_TABS_STATE, { type: "close" }).state).toBe(INITIAL_MOBILE_TABS_STATE) + }) + + test("disposing mid-close clears the timer and ignores later events", () => { + const result = replay([opened, settings, { type: "disposed" }]) + expect(result.effects.at(-1)).toEqual({ type: "timer.clear" }) + expect(transitionMobileTabs(result.state, gone).effects).toEqual([]) + expect(transitionMobileTabs(result.state, { type: "close.timed-out", attempt: 1 }).effects).toEqual([]) + }) +}) diff --git a/packages/app/src/shell/titlebar/mobile-tabs-machine.ts b/packages/app/src/shell/titlebar/mobile-tabs-machine.ts new file mode 100644 index 00000000000..18b97056417 --- /dev/null +++ b/packages/app/src/shell/titlebar/mobile-tabs-machine.ts @@ -0,0 +1,102 @@ +// The drawer's exit transition takes 200ms; Settings opens anyway if it never reports the end. +export const MOBILE_TABS_CLOSE_TIMEOUT_MS = 500 + +/** + * The phone tabs drawer. `closing-to-settings` lets the drawer slide out before Settings opens, so the two do not + * fight over focus and history. + */ +export type MobileTabsState = + | { readonly status: "closed"; readonly attempt: number } + | { readonly status: "open"; readonly attempt: number } + | { readonly status: "closing-to-settings"; readonly attempt: number } + | { readonly status: "disposed" } + +export type MobileTabsEvent = + /** The drawer asks to open or close (trigger, swipe, outside tap, Escape). */ + | { readonly type: "drawer.changed"; readonly open: boolean } + /** A tab, Home, New session or Help was picked. */ + | { readonly type: "close" } + | { readonly type: "settings.requested" } + | { readonly type: "content.present"; readonly present: boolean } + | { readonly type: "close.timed-out"; readonly attempt: number } + | { readonly type: "route.changed" } + | { readonly type: "viewport.changed"; readonly mobile: boolean } + | { readonly type: "disposed" } + +export type MobileTabsEffect = + | { readonly type: "timer.start"; readonly attempt: number; readonly timeoutMs: number } + | { readonly type: "timer.clear" } + | { readonly type: "settings.open" } + +export type MobileTabsTransition = { + readonly state: MobileTabsState + readonly effects: readonly MobileTabsEffect[] +} + +export const INITIAL_MOBILE_TABS_STATE: MobileTabsState = Object.freeze({ status: "closed", attempt: 0 }) + +const DISPOSED: MobileTabsState = Object.freeze({ status: "disposed" }) + +const NONE: readonly MobileTabsEffect[] = [] + +const CLEAR: readonly MobileTabsEffect[] = [{ type: "timer.clear" }] + +const OPEN_SETTINGS: readonly MobileTabsEffect[] = [{ type: "timer.clear" }, { type: "settings.open" }] + +export function transitionMobileTabs(state: MobileTabsState, event: MobileTabsEvent): MobileTabsTransition { + if (state.status === "disposed") return unchanged(state) + const closing = state.status === "closing-to-settings" + + if (event.type === "disposed") return { state: DISPOSED, effects: closing ? CLEAR : NONE } + + if (event.type === "drawer.changed") { + // A close the drawer reports while it slides out to Settings is the one already under way. + if (event.open === (state.status === "open") || (closing && !event.open)) return unchanged(state) + + return { + state: { status: event.open ? "open" : "closed", attempt: state.attempt }, + effects: closing ? CLEAR : NONE, + } + } + + if (event.type === "close" || event.type === "route.changed") { + if (state.status === "closed") return unchanged(state) + + return { state: { status: "closed", attempt: state.attempt }, effects: closing ? CLEAR : NONE } + } + + if (event.type === "settings.requested") { + if (state.status !== "open") return unchanged(state) + const attempt = state.attempt + 1 + + return { + state: { status: "closing-to-settings", attempt }, + effects: [{ type: "timer.start", attempt, timeoutMs: MOBILE_TABS_CLOSE_TIMEOUT_MS }], + } + } + + if (event.type === "content.present") { + if (!closing || event.present) return unchanged(state) + + return { state: { status: "closed", attempt: state.attempt }, effects: OPEN_SETTINGS } + } + + if (event.type === "close.timed-out") { + if (!closing || event.attempt !== state.attempt) return unchanged(state) + + return { state: { status: "closed", attempt: state.attempt }, effects: OPEN_SETTINGS } + } + + // Leaving the phone layout unmounts the drawer before it can report the end of its exit. + if (event.mobile || state.status === "closed") return unchanged(state) + + return { state: { status: "closed", attempt: state.attempt }, effects: closing ? OPEN_SETTINGS : NONE } +} + +export function selectMobileTabsOpen(state: MobileTabsState) { + return state.status === "open" +} + +function unchanged(state: MobileTabsState): MobileTabsTransition { + return { state, effects: NONE } +} diff --git a/packages/app/src/shell/titlebar/tab-popover-machine.test.ts b/packages/app/src/shell/titlebar/tab-popover-machine.test.ts new file mode 100644 index 00000000000..8957370ab2f --- /dev/null +++ b/packages/app/src/shell/titlebar/tab-popover-machine.test.ts @@ -0,0 +1,132 @@ +import { describe, expect, test } from "bun:test" +import { + INITIAL_TAB_PREVIEW_STATE, + selectTabPreviewFollowCard, + selectTabPreviewInstant, + selectTabPreviewOpenDelay, + TAB_PREVIEW_OPEN_DELAY_MS, + transitionTabPreview, + type TabPreviewEffect, + type TabPreviewEvent, + type TabPreviewOwner, + type TabPreviewState, +} from "./tab-popover-machine" + +type El = { readonly id: string } + +const owner = (): TabPreviewOwner => ({ close: () => {} }) + +const el = (id: string): El => ({ id }) + +const replay = (events: TabPreviewEvent[], state: TabPreviewState = INITIAL_TAB_PREVIEW_STATE) => + events.reduce<{ state: TabPreviewState; effects: TabPreviewEffect[] }>( + (current, event) => { + const next = transitionTabPreview(current.state, event) + + return { state: next.state, effects: [...current.effects, ...next.effects] } + }, + { state, effects: [] }, + ) + +const attach = (by: TabPreviewOwner, trigger: El, card: El, reducedMotion = false): TabPreviewEvent => ({ + type: "follow.attached", + owner: by, + trigger, + card, + reducedMotion, +}) + +describe("tab preview", () => { + test("closing a following card stops following its row", () => { + const a = owner() + const row = el("row-a") + const card = el("card-a") + const open = replay([{ type: "preview.opened", owner: a }, attach(a, row, card)]) + expect(open.effects).toEqual([{ type: "follow.start", trigger: row, card }]) + expect(selectTabPreviewFollowCard(open.state, row)).toBe(card) + + const closed = transitionTabPreview(open.state, { type: "preview.closed", owner: a }) + expect(closed.effects).toEqual([{ type: "follow.stop" }, { type: "warm.start", attempt: 1, delayMs: 500 }]) + // Pointer moves over the closed row no longer place a card. + expect(selectTabPreviewFollowCard(closed.state, row)).toBeUndefined() + }) + + test("a neighbouring tab takes over at once and closes the previous preview", () => { + const a = owner() + const b = owner() + const rowA = el("row-a") + const open = replay([{ type: "preview.opened", owner: a }, attach(a, rowA, el("card-a"))]).state + expect(selectTabPreviewInstant(open)).toBe(false) + expect(selectTabPreviewOpenDelay(open)).toBe(0) + + const handoff = transitionTabPreview(open, { type: "preview.opened", owner: b }) + expect(handoff.effects).toEqual([{ type: "follow.stop" }, { type: "owner.close", owner: a }]) + expect(selectTabPreviewInstant(handoff.state)).toBe(true) + expect(selectTabPreviewFollowCard(handoff.state, rowA)).toBeUndefined() + + // The closed tab reports back; it no longer owns the preview. + const stale = transitionTabPreview(handoff.state, { type: "preview.closed", owner: a }) + expect(stale.state).toBe(handoff.state) + expect(stale.effects).toEqual([]) + // A follow from the previous card's late mount is ignored too. + expect(transitionTabPreview(handoff.state, attach(a, rowA, el("card-a"))).state).toBe(handoff.state) + }) + + test("the warm window skips the open delay until it expires", () => { + const b = owner() + const c = owner() + + const warm = replay([ + { type: "preview.opened", owner: b }, + { type: "owner.disposed", owner: b }, + ]) + + expect(warm.state).toEqual({ status: "warm", attempt: 1, instant: false }) + expect(selectTabPreviewOpenDelay(warm.state)).toBe(0) + + const reopened = transitionTabPreview(warm.state, { type: "preview.opened", owner: c }) + expect(reopened.effects).toEqual([{ type: "warm.clear" }]) + expect(selectTabPreviewInstant(reopened.state)).toBe(true) + // The first window's timer fires late. + expect(transitionTabPreview(reopened.state, { type: "warm.expired", attempt: 1 }).state).toBe(reopened.state) + + const rewarmed = transitionTabPreview(reopened.state, { type: "preview.closed", owner: c }) + expect(rewarmed.effects).toEqual([{ type: "warm.start", attempt: 2, delayMs: 500 }]) + expect(transitionTabPreview(rewarmed.state, { type: "warm.expired", attempt: 1 }).state).toBe(rewarmed.state) + + const cold = transitionTabPreview(rewarmed.state, { type: "warm.expired", attempt: 2 }) + expect(cold.state.status).toBe("cold") + expect(selectTabPreviewOpenDelay(cold.state)).toBe(TAB_PREVIEW_OPEN_DELAY_MS) + expect(selectTabPreviewInstant(cold.state)).toBe(false) + }) + + test("reduced motion keeps the card in place", () => { + const a = owner() + const row = el("row-a") + const open = replay([{ type: "preview.opened", owner: a }, attach(a, row, el("card-a"), true)]) + expect(open.effects).toEqual([]) + expect(selectTabPreviewFollowCard(open.state, row)).toBeUndefined() + }) + + test("the same card attaching again does not restart following", () => { + const a = owner() + const row = el("row-a") + const card = el("card-a") + const open = replay([{ type: "preview.opened", owner: a }, attach(a, row, card)]).state + expect(transitionTabPreview(open, attach(a, row, card)).state).toBe(open) + + const remounted = transitionTabPreview(open, attach(a, row, el("card-a2"))) + expect(remounted.effects).toEqual([ + { type: "follow.stop" }, + { type: "follow.start", trigger: row, card: { id: "card-a2" } }, + ]) + }) + + test("closes and disposals of a tab that is not showing change nothing", () => { + const a = owner() + const cold = INITIAL_TAB_PREVIEW_STATE + expect(transitionTabPreview(cold, { type: "preview.closed", owner: a }).state).toBe(cold) + expect(transitionTabPreview(cold, { type: "owner.disposed", owner: a }).state).toBe(cold) + expect(transitionTabPreview(cold, { type: "warm.expired", attempt: 0 }).state).toBe(cold) + }) +}) diff --git a/packages/app/src/shell/titlebar/tab-popover-machine.ts b/packages/app/src/shell/titlebar/tab-popover-machine.ts new file mode 100644 index 00000000000..ab87ed8d799 --- /dev/null +++ b/packages/app/src/shell/titlebar/tab-popover-machine.ts @@ -0,0 +1,139 @@ +// Initial hover delay before the preview appears, per design. +export const TAB_PREVIEW_OPEN_DELAY_MS = 750 + +// After a preview closes, hovering a neighbouring tab within this window skips the open delay, as the tooltip's +// skipDelayDuration does, so moving across tabs doesn't re-wait the full delay each time. +export const TAB_PREVIEW_SKIP_WINDOW_MS = 500 + +/** One tab's preview. `close` asks that tab to close its preview when another one takes over. */ +export type TabPreviewOwner = { + readonly close: () => void +} + +/** The vertical row a card follows the pointer over, and the card itself. */ +export type TabPreviewFollow = { + readonly trigger: El + readonly card: El +} + +/** + * The one tab preview shared by every tab strip. `cold` waits the full open delay; `open` and `warm` (just closed) + * open the next preview at once. `instant` marks a preview opened during such a streak, which shows without animating. + */ +export type TabPreviewState = + | { readonly status: "cold"; readonly attempt: number } + | { + readonly status: "open" + readonly attempt: number + readonly owner: TabPreviewOwner + readonly instant: boolean + readonly follow: TabPreviewFollow | undefined + } + | { readonly status: "warm"; readonly attempt: number; readonly instant: boolean } + +export type TabPreviewEvent = + | { readonly type: "preview.opened"; readonly owner: TabPreviewOwner } + | { readonly type: "preview.closed"; readonly owner: TabPreviewOwner } + | { readonly type: "owner.disposed"; readonly owner: TabPreviewOwner } + | { + readonly type: "follow.attached" + readonly owner: TabPreviewOwner + readonly trigger: El + readonly card: El + readonly reducedMotion: boolean + } + | { readonly type: "warm.expired"; readonly attempt: number } + +export type TabPreviewEffect = + | { readonly type: "owner.close"; readonly owner: TabPreviewOwner } + | { readonly type: "follow.start"; readonly trigger: El; readonly card: El } + | { readonly type: "follow.stop" } + | { readonly type: "warm.start"; readonly attempt: number; readonly delayMs: number } + | { readonly type: "warm.clear" } + +export type TabPreviewTransition = { + readonly state: TabPreviewState + readonly effects: readonly TabPreviewEffect[] +} + +export const INITIAL_TAB_PREVIEW_STATE: TabPreviewState = Object.freeze({ status: "cold", attempt: 0 }) + +const NONE: readonly never[] = [] + +const STOP: readonly TabPreviewEffect[] = [{ type: "follow.stop" }] + +export function transitionTabPreview( + state: TabPreviewState, + event: TabPreviewEvent, +): TabPreviewTransition { + if (event.type === "preview.opened") { + if (state.status === "open" && state.owner === event.owner) return unchanged(state) + + const next: TabPreviewState = { + status: "open", + attempt: state.attempt, + owner: event.owner, + instant: state.status !== "cold", + follow: undefined, + } + + if (state.status === "cold") return { state: next, effects: NONE } + + if (state.status === "warm") return { state: next, effects: [{ type: "warm.clear" }] } + + // Another tab's preview takes over at once and closes the one that was up. + return { state: next, effects: [...stop(state), { type: "owner.close", owner: state.owner }] } + } + + if (event.type === "preview.closed" || event.type === "owner.disposed") { + if (state.status !== "open" || state.owner !== event.owner) return unchanged(state) + const attempt = state.attempt + 1 + + return { + state: { status: "warm", attempt, instant: state.instant }, + effects: [...stop(state), { type: "warm.start", attempt, delayMs: TAB_PREVIEW_SKIP_WINDOW_MS }], + } + } + + if (event.type === "follow.attached") { + if (state.status !== "open" || state.owner !== event.owner) return unchanged(state) + + if (event.reducedMotion) + return state.follow ? { state: { ...state, follow: undefined }, effects: STOP } : unchanged(state) + + if (state.follow?.trigger === event.trigger && state.follow.card === event.card) return unchanged(state) + + return { + state: { ...state, follow: { trigger: event.trigger, card: event.card } }, + effects: [...stop(state), { type: "follow.start", trigger: event.trigger, card: event.card }], + } + } + + if (state.status !== "warm" || state.attempt !== event.attempt) return unchanged(state) + + return { state: { status: "cold", attempt: state.attempt }, effects: NONE } +} + +/** Kobalte reads the open delay when the pointer enters a trigger, so a streak skips it. */ +export function selectTabPreviewOpenDelay(state: TabPreviewState) { + return state.status === "cold" ? TAB_PREVIEW_OPEN_DELAY_MS : 0 +} + +export function selectTabPreviewInstant(state: TabPreviewState) { + return state.status !== "cold" && state.instant +} + +/** The card that follows the pointer over `trigger`, when `trigger` owns the open preview in the vertical strip. */ +export function selectTabPreviewFollowCard(state: TabPreviewState, trigger: El | undefined) { + if (state.status !== "open" || state.follow === undefined || state.follow.trigger !== trigger) return + + return state.follow.card +} + +function stop(state: Extract, { status: "open" }>): readonly TabPreviewEffect[] { + return state.follow ? STOP : NONE +} + +function unchanged(state: TabPreviewState): TabPreviewTransition { + return { state, effects: NONE } +} diff --git a/packages/app/src/shell/titlebar/tab-popover.tsx b/packages/app/src/shell/titlebar/tab-popover.tsx index 73333cb1145..3c433c54ccb 100644 --- a/packages/app/src/shell/titlebar/tab-popover.tsx +++ b/packages/app/src/shell/titlebar/tab-popover.tsx @@ -1,27 +1,70 @@ import { HoverCard } from "@kobalte/core/hover-card" import { prefersReducedMotion } from "@opencode/ui/motion" -import { createEffect, createSignal, For, on, onCleanup, Show, type JSXElement } from "solid-js" +import { createComputed, createSignal, For, onCleanup, Show, untrack, type JSXElement } from "solid-js" import { useLanguage } from "@/runtime/i18n/language" import { createMediaQuery } from "@solid-primitives/media" +import { + INITIAL_TAB_PREVIEW_STATE, + selectTabPreviewFollowCard, + selectTabPreviewInstant, + selectTabPreviewOpenDelay, + transitionTabPreview, + type TabPreviewEffect, + type TabPreviewEvent, + type TabPreviewOwner, + type TabPreviewState, +} from "./tab-popover-machine" import "./tab-popover.css" -// Initial hover delay before the preview appears, per design. -const OPEN_DELAY = 750 - const CLOSE_DELAY = 0 -// After a preview closes, hovering a neighbouring tab within this window skips -// the open delay — mirrors the tooltip's skipDelayDuration so moving across -// tabs doesn't re-wait the full delay each time. -const SKIP_WINDOW = 500 - -let lastClosedAt = 0 - -let activePreview: (() => void) | undefined +// One preview is up at a time across every tab strip, so the machine is shared. +const [previewState, setPreviewState] = createSignal(INITIAL_TAB_PREVIEW_STATE) // In the vertical strip, the card follows the pointer's height over its row, clamped to the tabs, so moving down the -// tabs reads as one card following the cursor. -const follow: Follow = { pointerY: 0 } +// tabs reads as one card following the cursor. The last pointer height over a row, and the rects the card clamps +// against, measured once per card. +let pointerY = 0 + +let rects: { row: DOMRect; bounds: DOMRect; card: number } | undefined + +let measureFrame: number | undefined + +let unwatch: (() => void) | undefined + +let warmTimer: ReturnType | undefined + +function dispatch(event: TabPreviewEvent) { + const previous = untrack(previewState) + const next = transitionTabPreview(previous, event) + + if (next.state !== previous) setPreviewState(next.state) + next.effects.forEach(run) +} + +function run(effect: TabPreviewEffect) { + if (effect.type === "owner.close") return effect.owner.close() + + if (effect.type === "follow.start") return follow(effect.trigger, effect.card) + + if (effect.type === "follow.stop") { + unwatch?.() + unwatch = undefined + + if (measureFrame !== undefined) cancelAnimationFrame(measureFrame) + measureFrame = undefined + rects = undefined + + return + } + + clearTimeout(warmTimer) + warmTimer = undefined + + if (effect.type === "warm.clear") return + const attempt = effect.attempt + warmTimer = setTimeout(() => dispatch({ type: "warm.expired", attempt }), effect.delayMs) +} export interface TabPreviewData { projectName?: string @@ -40,57 +83,16 @@ export function TabPreviewPopover(props: { const language = useLanguage() const mobile = createMediaQuery("(max-width: 767px)") let triggerEl: HTMLDivElement | undefined - // When opened during a rapid tab-hopping streak, this preview appears and - // disappears instantly (no repeated enter/exit animation) — only the first, - // "cold" preview animates. Mirrors how browsers reuse one tab tooltip. - const [instant, setInstant] = createSignal(false) - - const warm = () => !!activePreview || Date.now() - lastClosedAt < SKIP_WINDOW + const owner: TabPreviewOwner = { close: () => props.onOpenChange(false) } const open = () => props.open && !mobile() - const close = () => props.onOpenChange(false) - // Observe accepted, controlled state, including drag/menu suppression in TabNav. - createEffect(() => { - if (open()) { - if (activePreview !== close) activePreview?.() - activePreview = close - - return - } - - if (activePreview !== close) return - activePreview = undefined - lastClosedAt = Date.now() + // Observe accepted, controlled state, including drag/menu suppression in TabNav. A computed commits the preview + // before Kobalte mounts the card, so the card's ref and `data-instant` already see it. + createComputed(() => { + const type = open() ? "preview.opened" : "preview.closed" + untrack(() => dispatch({ type, owner })) }) - createEffect( - on( - open, - (now, before) => { - if (!before || now || !triggerEl || triggerEl !== follow.trigger) return - unwatch() - follow.card = undefined - }, - { defer: true }, - ), - ) - onCleanup(() => { - if (follow.trigger === triggerEl) { - unwatch() - Object.assign(follow, { trigger: undefined, card: undefined }) - } - - if (activePreview !== close) return - activePreview = undefined - lastClosedAt = Date.now() - }) - // Kobalte reads openDelay lazily when the pointer enters the trigger, so this - // resolves the skip window per-hover. - const resolveOpenDelay = () => (warm() ? 0 : OPEN_DELAY) - - const handleOpenChange = (open: boolean) => { - if (open) setInstant(warm()) - props.onOpenChange(open) - } + onCleanup(() => dispatch({ type: "owner.disposed", owner })) // Kept out of JSX: an inline nested ternary compiles to a memo created on every read, and Kobalte reads // placement from a ResizeObserver callback, where that memo has no owner and is never disposed. @@ -100,8 +102,9 @@ export function TabPreviewPopover(props: { return ( { - follow.pointerY = event.clientY + pointerY = event.clientY + const card = selectTabPreviewFollowCard(previewState(), triggerEl) - if (props.orientation === "vertical" && triggerEl === follow.trigger) place() + if (card && triggerEl) place(triggerEl, card) }} > {props.trigger} @@ -130,10 +134,19 @@ export function TabPreviewPopover(props: { if (theme) el.setAttribute("data-theme", theme) - if (triggerEl && props.orientation === "vertical") show(el, triggerEl) + if (triggerEl && props.orientation === "vertical") + dispatch({ + type: "follow.attached", + owner, + trigger: triggerEl, + card: el, + reducedMotion: prefersReducedMotion(), + }) }} data-component="session-tab-popover" - data-instant={instant() || undefined} + // During a rapid tab-hopping streak the preview appears and disappears without animating; only the first, + // cold preview animates, as browsers reuse one tab tooltip. + data-instant={selectTabPreviewInstant(previewState()) || undefined} >
@@ -171,78 +184,59 @@ export function TabPreviewPopover(props: { ) } -function show(card: HTMLElement, trigger: HTMLElement) { - Object.assign(follow, { card, trigger, rects: undefined }) - unwatch() - - if (prefersReducedMotion()) return - watch(trigger) - place() +function follow(trigger: HTMLElement, card: HTMLElement) { + rects = undefined + watch(trigger, card) + place(trigger, card) // The card has no height while it mounts, so clamp again once it's laid out. - if (!follow.rects) requestAnimationFrame(place) + if (rects) return + measureFrame = requestAnimationFrame(() => { + measureFrame = undefined + place(trigger, card) + }) } // Moves the card straight to the pointer, with no spring. -function place() { - const card = follow.card - - if (!card?.isConnected || prefersReducedMotion()) return - card.style.transform = `translateY(${cursorOffset()}px)` +function place(trigger: HTMLElement, card: HTMLElement) { + if (!card.isConnected || prefersReducedMotion()) return + card.style.transform = `translateY(${cursorOffset(trigger, card)}px)` } // Keeps the pointer level with the middle of the row-sized slot the card would sit in by default, so the offset is 0 // at the row's centre and runs continuously across row boundaries, clamped to the sidebar. -function cursorOffset() { - const rects = follow.rects ?? measure() - - if (!rects) return 0 +function cursorOffset(trigger: HTMLElement, card: HTMLElement) { + const measured = rects ?? measure(trigger, card) // The card has no height until it's attached, so a measurement taken as it mounts isn't kept. - if (rects.card > 0) follow.rects = rects - const top = follow.pointerY - rects.row.height / 2 - const clamped = Math.min(Math.max(top, rects.bounds.top), rects.bounds.bottom - rects.card) + if (measured.card > 0) rects = measured + const top = pointerY - measured.row.height / 2 + const clamped = Math.min(Math.max(top, measured.bounds.top), measured.bounds.bottom - measured.card) - return clamped - rects.row.top + return clamped - measured.row.top } -function measure() { - if (!follow.trigger || !follow.card) return - const bounds = (follow.trigger.closest('[data-slot="vertical-tabs"]') ?? follow.trigger).getBoundingClientRect() +function measure(trigger: HTMLElement, card: HTMLElement) { + const bounds = (trigger.closest('[data-slot="vertical-tabs"]') ?? trigger).getBoundingClientRect() - return { row: follow.trigger.getBoundingClientRect(), bounds, card: follow.card.offsetHeight } + return { row: trigger.getBoundingClientRect(), bounds, card: card.offsetHeight } } // While a card is up, scrolling or resizing the tabs moves the rows under the cached rects, so measure again and // re-clamp the card even if the pointer stays still. -function watch(trigger: HTMLElement) { +function watch(trigger: HTMLElement, card: HTMLElement) { const refresh = () => { - follow.rects = undefined - place() + rects = undefined + place(trigger, card) } const observer = new ResizeObserver(refresh) observer.observe(trigger.closest('[data-slot="vertical-tabs"]') ?? trigger) window.addEventListener("scroll", refresh, { capture: true, passive: true }) window.addEventListener("resize", refresh, { passive: true }) - follow.unwatch = () => { + unwatch = () => { observer.disconnect() window.removeEventListener("scroll", refresh, { capture: true }) window.removeEventListener("resize", refresh) } } - -function unwatch() { - follow.unwatch?.() - follow.unwatch = undefined -} - -type Follow = { - // The row whose preview is up, or closed last. - trigger?: HTMLElement - card?: HTMLElement - // The last pointer height over a row, and the rects the card clamps against, measured once per card. - pointerY: number - rects?: { row: DOMRect; bounds: DOMRect; card: number } - unwatch?: () => void -} diff --git a/packages/app/src/shell/titlebar/titlebar.tsx b/packages/app/src/shell/titlebar/titlebar.tsx index 48ec60b52cb..114b3954fea 100644 --- a/packages/app/src/shell/titlebar/titlebar.tsx +++ b/packages/app/src/shell/titlebar/titlebar.tsx @@ -1,5 +1,4 @@ -import { createEffect, createMemo, Match, onCleanup, Show, Switch } from "solid-js" -import { createStore } from "solid-js/store" +import { createEffect, createMemo, createSignal, Match, on, onCleanup, Show, Switch, untrack } from "solid-js" import { Portal } from "solid-js/web" import { useLocation } from "@solidjs/router" import { uuid } from "@opencode/util/uuid" @@ -37,6 +36,12 @@ import { RecentlyClosedTabsMenu } from "./recently-closed-tabs-menu" import { useSettingsDialog } from "@/settings/command" import { TitlebarItems, useTitlebarItems } from "@/runtime/plugin/titlebar-items" import { createRouteTabSync } from "./route-sync" +import { + INITIAL_MOBILE_TABS_STATE, + selectMobileTabsOpen, + transitionMobileTabs, + type MobileTabsEvent, +} from "./mobile-tabs-machine" export const newTabCommand = { id: "tab.new", keybind: "mod+t,mod+n" } @@ -486,7 +491,29 @@ export function Titlebar(props: { verticalTabs?: { mount?: HTMLElement } }) { }, ]) - const [mobileTabs, setMobileTabs] = createStore({ open: false, settings: false }) + const [mobileTabsState, setMobileTabsState] = createSignal(INITIAL_MOBILE_TABS_STATE) + let closeTimer: ReturnType | undefined + + const dispatchMobileTabs = (event: MobileTabsEvent) => { + const previous = untrack(mobileTabsState) + const next = transitionMobileTabs(previous, event) + + if (next.state !== previous) setMobileTabsState(next.state) + next.effects.forEach((effect) => { + if (effect.type === "settings.open") return openSettings() + clearTimeout(closeTimer) + closeTimer = undefined + + if (effect.type === "timer.clear") return + const attempt = effect.attempt + closeTimer = setTimeout( + () => dispatchMobileTabs({ type: "close.timed-out", attempt }), + effect.timeoutMs, + ) + }) + } + + const closeMobileTabs = () => dispatchMobileTabs({ type: "close" }) // The current tab's project avatar stays put; while it works, its activity ring shows beside the tab count. const currentStatus = useSessionTabAvatarState( @@ -518,11 +545,11 @@ export function Titlebar(props: { verticalTabs?: { mount?: HTMLElement } }) { ) } - createEffect(() => { - path() - mobile() - setMobileTabs("open", false) - }) + createEffect(on(path, () => dispatchMobileTabs({ type: "route.changed" }), { defer: true })) + createEffect( + on(mobile, (value) => dispatchMobileTabs({ type: "viewport.changed", mobile: value }), { defer: true }), + ) + onCleanup(() => dispatchMobileTabs({ type: "disposed" })) return (
setMobileTabs("open", open)} - onContentPresentChange={(present) => { - if (present || !mobileTabs.settings) return - setMobileTabs("settings", false) - openSettings() - }} + open={selectMobileTabsOpen(mobileTabsState())} + onOpenChange={(open) => dispatchMobileTabs({ type: "drawer.changed", open })} + onContentPresentChange={(present) => dispatchMobileTabs({ type: "content.present", present })} > { tabs.select(tab) - setMobileTabs("open", false) + closeMobileTabs() }} onClose={(tab) => { const index = tabsStore.findIndex((item) => tabKey(item) === tabKey(tab)) @@ -633,7 +656,7 @@ export function Titlebar(props: { verticalTabs?: { mount?: HTMLElement } }) { class="flex h-7 w-full shrink-0 items-center gap-2 rounded-[6px] px-2 text-[13px] leading-4 text-v2-text-text-base hover:bg-v2-background-bg-layer-02 focus-visible:outline-none focus-visible:bg-v2-background-bg-layer-02" onClick={() => { openNewTab() - setMobileTabs("open", false) + closeMobileTabs() }} > @@ -648,7 +671,7 @@ export function Titlebar(props: { verticalTabs?: { mount?: HTMLElement } }) { class="flex h-7 w-full items-center gap-2 rounded-[6px] px-2 text-[13px] leading-4 text-v2-text-text-faint data-[state=pressed]:text-v2-text-text-base focus-visible:outline-none" onClick={() => { if (layout.route().type !== "home") toggleHome() - setMobileTabs("open", false) + closeMobileTabs() }} > @@ -659,7 +682,7 @@ export function Titlebar(props: { verticalTabs?: { mount?: HTMLElement } }) { type="button" data-action="mobile-tabs-settings" class="flex h-7 min-w-0 flex-1 items-center gap-2 rounded-[6px] px-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 focus-visible:outline-none focus-visible:bg-v2-background-bg-layer-02" - onClick={() => setMobileTabs({ open: false, settings: true })} + onClick={() => dispatchMobileTabs({ type: "settings.requested" })} > {language.t("sidebar.settings")} @@ -669,7 +692,7 @@ export function Titlebar(props: { verticalTabs?: { mount?: HTMLElement } }) { data-action="mobile-tabs-help" class="flex h-7 shrink-0 items-center gap-2 rounded-[6px] px-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 focus-visible:outline-none focus-visible:bg-v2-background-bg-layer-02" onClick={() => { - setMobileTabs("open", false) + closeMobileTabs() platform.openExternal("https://opencode.ai/desktop-feedback") }} >