From 5eeb906b27f993c26037196b6d4a2a95cb606f6b Mon Sep 17 00:00:00 2001 From: Luke Parker <10430890+Hona@users.noreply.github.com> Date: Wed, 4 Nov 2026 21:38:00 -0600 Subject: [PATCH] fix(ui): drive the dialog stack through one state machine (#61903) --- .../component-tests/plugin-host.fixture.tsx | 4 +- .../app/component-tests/plugin-host.spec.ts | 60 +++ .../app/src/servers/connect/controller.ts | 9 + packages/app/src/servers/connect/dialog.tsx | 1 + .../ui/src/context/dialog-machine.test.ts | 295 +++++++++++++++ packages/ui/src/context/dialog-machine.ts | 280 ++++++++++++++ packages/ui/src/context/dialog.tsx | 343 +++++++++--------- .../ui/src/overlays/dialog/dialog.stories.tsx | 58 ++- packages/ui/src/overlays/dialog/dialog.tsx | 8 +- 9 files changed, 877 insertions(+), 181 deletions(-) create mode 100644 packages/ui/src/context/dialog-machine.test.ts create mode 100644 packages/ui/src/context/dialog-machine.ts diff --git a/packages/app/component-tests/plugin-host.fixture.tsx b/packages/app/component-tests/plugin-host.fixture.tsx index abd02c831e6..da791f8902d 100644 --- a/packages/app/component-tests/plugin-host.fixture.tsx +++ b/packages/app/component-tests/plugin-host.fixture.tsx @@ -1,5 +1,5 @@ import type { PluginInfo, SessionMessageInfo } from "@opencode/client/promise" -import { DialogProvider } from "@opencode/ui/context/dialog" +import { DialogProvider, useDialog } from "@opencode/ui/context/dialog" import { Menu } from "@opencode/ui/menu" import { Toast } from "@opencode/ui/toast" import { @@ -82,7 +82,7 @@ type Captured = { apis?: ReturnType } /** A value the fixture's storage holds as JSON. */ type Json = string | number | boolean | null | readonly Json[] | { readonly [key: string]: Json } -export { createComponent, createMemo, createRoot, createSignal, getOwner, onCleanup, runWithOwner } +export { createComponent, createMemo, createRoot, createSignal, getOwner, onCleanup, runWithOwner, useDialog } const layout: BuiltinLayout = { narrow: () => false, diff --git a/packages/app/component-tests/plugin-host.spec.ts b/packages/app/component-tests/plugin-host.spec.ts index 48a7f27adcc..0b139e37e2a 100644 --- a/packages/app/component-tests/plugin-host.spec.ts +++ b/packages/app/component-tests/plugin-host.spec.ts @@ -179,6 +179,66 @@ story("a dialog handle closes its own dialog, and a dialog closes with the scope }) }) +story("Escape closes the top dialog while a dialog below it plays its exit animation", async ({ page }) => { + const result = await page.evaluate(async (fixture) => { + const { mountPluginHost, until } = await import(fixture) + const host = mountPluginHost() + const text = (value: string) => () => Object.assign(document.createElement("p"), { textContent: value }) + const shown = () => ["below", "middle", "top"].filter((value) => document.body.textContent?.includes(value)) + const handles: DialogHandle[] = [] + host.load((ctx: Context) => { + handles.push(ctx.dialogs.open(text("below")), ctx.dialogs.open(text("middle")), ctx.dialogs.open(text("top"))) + }, 0) + await until(() => shown().length === 3) + handles[1]?.close() + // In the same tick, so the middle dialog is still playing its exit animation. + document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true })) + await until(() => shown().length === 1) + const outcome = shown() + host.unmount() + + return outcome + }, fixture) + + expect(result).toEqual(["below"]) +}) + +story("a dialog closes itself while the dialog above it exits, and a double close never reaches below", async ({ + page, +}) => { + const result = await page.evaluate(async (fixture) => { + const { mountPluginHost, until, useDialog } = await import(fixture) + const host = mountPluginHost() + const shown = () => ["base", "middle", "top"].filter((value) => document.body.textContent?.includes(value)) + const own = { close: () => {} } + host.load((ctx: Context) => { + ctx.dialogs.open(() => Object.assign(document.createElement("p"), { textContent: "base" })) + // A Cancel button inside the middle dialog: a plain close() from its own layer. + ctx.dialogs.open(() => { + const dialog = useDialog() + own.close = () => dialog.close() + + return Object.assign(document.createElement("p"), { textContent: "middle" }) + }) + ctx.dialogs.open(() => Object.assign(document.createElement("p"), { textContent: "top" })) + }, 0) + await until(() => shown().length === 3) + document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true })) + // In the same tick, while the top dialog is still playing its exit animation; twice, as a double click would. + own.close() + own.close() + await until(() => shown().length === 1) + // Past every exit animation, so a close that reached the base dialog would have removed it by now. + await new Promise((resolve) => setTimeout(resolve, 300)) + const outcome = shown() + host.unmount() + + return outcome + }, fixture) + + expect(result).toEqual(["base"]) +}) + story("a dialog pushed in the same tick as a reload never mounts", async ({ page }) => { const shown = await page.evaluate(async (fixture) => { const { mountPluginHost } = await import(fixture) diff --git a/packages/app/src/servers/connect/controller.ts b/packages/app/src/servers/connect/controller.ts index b303e783333..8415c6756a6 100644 --- a/packages/app/src/servers/connect/controller.ts +++ b/packages/app/src/servers/connect/controller.ts @@ -25,6 +25,8 @@ export type ServerConnectControllerOptions = readonly removeTabs: (key: ServerConnection.Key) => void /** Closes the dialog. `saved` is the server a successful save stored. */ readonly onClose: (saved: ServerConnection.Http | undefined) => void + /** True once the dialog starts closing, so a check that finishes during its exit animation saves nothing. */ + readonly closing?: Accessor } export function createServerConnectController(options: ServerConnectControllerOptions) { @@ -144,6 +146,13 @@ export function createServerConnectController(options: ServerConnectControllerOp if (options.surface === "dialog" && options.original) createEffect(on(options.original, (original) => dispatch({ type: "original.synced", original }))) + if (options.surface === "dialog" && options.closing) { + const closing = options.closing + createEffect(() => { + if (closing()) dispatch({ type: "disposed" }) + }) + } + onCleanup(() => dispatch({ type: "disposed" })) const view = createMemo(() => diff --git a/packages/app/src/servers/connect/dialog.tsx b/packages/app/src/servers/connect/dialog.tsx index 2e90fab8f79..96d38e19366 100644 --- a/packages/app/src/servers/connect/dialog.tsx +++ b/packages/app/src/servers/connect/dialog.tsx @@ -53,6 +53,7 @@ export const DialogServer: Component<{ target: edited ? { kind: "edit", original: untrack(original) ?? originalOf(edited) } : { kind: "add" }, original, removeTabs: (key) => tabs.removeServer(key), + closing: () => dialog.closing, // Close first: onSave may open the next dialog, such as the folder picker an interrupted action continues with. onClose: (saved) => { dialog.close() diff --git a/packages/ui/src/context/dialog-machine.test.ts b/packages/ui/src/context/dialog-machine.test.ts new file mode 100644 index 00000000000..0c64751a489 --- /dev/null +++ b/packages/ui/src/context/dialog-machine.test.ts @@ -0,0 +1,295 @@ +import { describe, expect, test } from "bun:test" +import { + createDialogStackState, + selectLayerClosing, + selectLayerIndex, + selectLayerModal, + selectTopDialog, + transitionDialogStack, + type DialogStackEffect, + type DialogStackEvent, + type DialogStackState, +} from "./dialog-machine" + +type Event = DialogStackEvent + +// Focus is where it was when the open was asked for; the request names the content the driver would mount. +const open = (mode: "show" | "push", id: string, aborted = false): Event => ({ + type: "open", + mode, + id, + aborted, + focus: `before ${id}`, + request: id, +}) + +const push = (id: string) => open("push", id) + +const show = (id: string) => open("show", id) + +function run(state: DialogStackState, ...events: Event[]) { + return events.reduce<{ state: DialogStackState; effects: readonly DialogStackEffect[] }>( + (result, event) => transitionDialogStack(result.state, event), + { state, effects: [] }, + ) +} + +function closed(attempt: number, delayMs: number, focus?: string): DialogStackEffect[] { + return [ + { type: "timer.start", attempt, delayMs }, + { type: "notify.close", attempt }, + ...(focus ? [{ type: "focus.return" as const, attempt, focus }] : []), + ] +} + +const statuses = (state: DialogStackState) => + state.status === "active" ? state.entries.map((entry) => `${entry.id}:${entry.status}`) : [] + +describe("closing a lower dialog by id", () => { + // A at the bottom plays the image preview's 960 ms flight out; B on top must close at once, however it is closed. + const below = run( + createDialogStackState(), + push("a"), + { type: "layer.exit-duration", attempt: 1, exitMs: 960 }, + push("b"), + { type: "close", id: "a" }, + ) + + test("starts only that dialog's exit and leaves focus with the top dialog", () => { + expect(below.effects).toEqual(closed(1, 960)) + expect(statuses(below.state)).toEqual(["a:closing", "b:open"]) + expect(selectTopDialog(below.state)?.id).toBe("b") + }) + + test.each<[string, Event]>([ + ["Escape", { type: "dismiss" }], + ["a backdrop click", { type: "backdrop.click", attempt: 2 }], + ["its close button", { type: "layer.dismiss", attempt: 2 }], + ["an un-keyed close", { type: "close" }], + ["a dismissal by id", { type: "dismiss", id: "b" }], + ])("does not block %s on the top dialog", (_, event) => { + const next = transitionDialogStack(below.state, event) + + expect(next.effects).toEqual(closed(2, 100, "before b")) + expect(statuses(next.state)).toEqual(["a:closing", "b:closing"]) + }) +}) + +describe("while the top dialog plays its exit animation", () => { + const exiting = run(createDialogStackState(), push("a"), push("b"), { type: "dismiss" }) + + test("the dialog below is the top dialog and owns the focus trap", () => { + expect(selectTopDialog(exiting.state)?.id).toBe("a") + expect(selectLayerModal(exiting.state, 1, false)).toBe(true) + expect(selectLayerModal(exiting.state, 2, false)).toBe(false) + expect(selectLayerModal(exiting.state, 1, true)).toBe(false) + }) + + test.each<[string, Event]>([ + ["its close button", { type: "layer.dismiss", attempt: 2 }], + ["its backdrop", { type: "backdrop.click", attempt: 2 }], + ["a dismissal by its id", { type: "dismiss", id: "b" }], + ["a second un-keyed close", { type: "close" }], + ["a second close from inside it", { type: "close", layer: 2 }], + ])("%s does nothing more", (_, event) => { + const next = transitionDialogStack(exiting.state, event) + + expect(next.state).toBe(exiting.state) + expect(next.effects).toEqual([]) + }) + + test.each<[string, Event]>([ + ["Escape", { type: "dismiss" }], + ["a dismissal by its id", { type: "dismiss", id: "a" }], + ["its close button", { type: "layer.dismiss", attempt: 1 }], + ["its backdrop", { type: "backdrop.click", attempt: 1 }], + ["a close by its id", { type: "close", id: "a" }], + ["its own Cancel (a close from inside it)", { type: "close", layer: 1 }], + ])("%s closes the dialog below at once", (_, event) => { + const next = transitionDialogStack(exiting.state, event) + + expect(next.effects).toEqual(closed(1, 100, "before a")) + expect(statuses(next.state)).toEqual(["a:closing", "b:closing"]) + }) + + test("an un-keyed close from outside every dialog waits for the exit, then closes the dialog below", () => { + const next = run(exiting.state, { type: "exit.completed", attempt: 2 }, { type: "close" }) + + expect(next.effects).toEqual(closed(1, 100, "before a")) + }) +}) + +describe("a close without an id from inside a dialog", () => { + const stacked = run(createDialogStackState(), push("a"), push("b")) + + test("closes that dialog, not the one on top, and leaves focus with the top dialog", () => { + const next = transitionDialogStack(stacked.state, { type: "close", layer: 1 }) + + expect(next.effects).toEqual(closed(1, 100)) + expect(statuses(next.state)).toEqual(["a:closing", "b:open"]) + }) + + test("closes only itself on a double click, never the dialog below", () => { + const first = transitionDialogStack(stacked.state, { type: "close", layer: 2 }) + const second = transitionDialogStack(first.state, { type: "close", layer: 2 }) + + expect(first.effects).toEqual(closed(2, 100, "before b")) + expect(second.state).toBe(first.state) + expect(second.effects).toEqual([]) + }) + + test("from a dialog a show replaced, closes the replacement, along a chain of replacements", () => { + const replaced = run(stacked.state, show("c")) + + expect(transitionDialogStack(replaced.state, { type: "close", layer: 1 }).effects).toEqual(closed(3, 100, "before a")) + + const again = run(replaced.state, show("d")) + + expect(transitionDialogStack(again.state, { type: "close", layer: 1 }).effects).toEqual(closed(4, 100, "before a")) + expect(transitionDialogStack(again.state, { type: "close", layer: 3 }).effects).toEqual(closed(4, 100, "before a")) + }) + + test.each<[string, Event[]]>([ + // Escape closed it, its exit ended, and another dialog opened before its async work called close(). + ["closed and gone", [push("a"), { type: "dismiss" }, { type: "exit.completed", attempt: 1 }, push("b")]], + ["closed, then torn down by a show", [push("a"), push("x"), { type: "close", id: "a" }, show("b")]], + ])("from a dialog already %s, closes nothing", (_, events) => { + const before = run(createDialogStackState(), ...events) + const next = transitionDialogStack(before.state, { type: "close", layer: 1 }) + + expect(next.state).toBe(before.state) + expect(next.effects).toEqual([]) + }) +}) + +test("a layer reads closing as soon as its close starts, before its exit animation ends", () => { + const opened = run(createDialogStackState(), push("a")) + const closing = run(opened.state, { type: "dismiss" }) + + expect(selectLayerClosing(opened.state, 1)).toBe(false) + expect(selectLayerClosing(closing.state, 1)).toBe(true) + // Escape stops being captured, though the dialog stays mounted for its exit animation. + expect(selectTopDialog(closing.state)).toBeUndefined() + expect(statuses(closing.state)).toEqual(["a:closing"]) + + const gone = run(closing.state, { type: "exit.completed", attempt: 1 }) + + expect(gone.effects).toEqual([{ type: "dispose", attempt: 1, notify: false }]) + expect(statuses(gone.state)).toEqual([]) +}) + +test("an id reused while its earlier dialog exits names only the new dialog", () => { + const reused = run(createDialogStackState(), push("x"), { type: "close", id: "x" }, push("x")) + + expect(selectTopDialog(reused.state)?.attempt).toBe(2) + expect(selectLayerClosing(reused.state, 1)).toBe(true) + expect(selectLayerClosing(reused.state, 2)).toBe(false) + + const exited = run(reused.state, { type: "exit.completed", attempt: 1 }) + + expect(exited.effects).toEqual([{ type: "dispose", attempt: 1, notify: false }]) + expect(statuses(exited.state)).toEqual(["x:open"]) + expect(selectLayerIndex(exited.state, 2)).toBe(0) + expect(run(exited.state, { type: "close", id: "x" }).effects).toEqual(closed(2, 100, "before x")) +}) + +describe("a dialog that opts out of backdrop dismissal", () => { + const kept = run(createDialogStackState(), push("a"), { type: "layer.backdrop-dismiss", attempt: 1, enabled: false }) + + test("stays open on a backdrop click", () => { + const next = transitionDialogStack(kept.state, { type: "backdrop.click", attempt: 1 }) + + expect(next.state).toBe(kept.state) + expect(next.effects).toEqual([]) + }) + + test.each<[string, Event]>([ + ["Escape", { type: "dismiss" }], + ["its close button", { type: "layer.dismiss", attempt: 1 }], + ["an un-keyed close", { type: "close" }], + ])("still closes on %s", (_, event) => { + expect(transitionDialogStack(kept.state, event).effects).toEqual(closed(1, 100, "before a")) + }) + + test("an unchanged setting writes nothing", () => { + const next = transitionDialogStack(kept.state, { type: "layer.backdrop-dismiss", attempt: 1, enabled: false }) + + expect(next.state).toBe(kept.state) + }) +}) + +test("a replacing dialog returns focus to the origin and never notifies a closing dialog again", () => { + const before = run(createDialogStackState(), push("a"), push("b"), { type: "close", id: "b" }) + const next = transitionDialogStack(before.state, show("c")) + + expect(next.effects).toEqual([ + { type: "dispose", attempt: 1, notify: true }, + { type: "timer.stop", attempt: 2 }, + { type: "dispose", attempt: 2, notify: false }, + { type: "mount", attempt: 3, id: "c", request: "c" }, + ]) + expect(statuses(next.state)).toEqual(["c:open"]) + expect(run(next.state, { type: "dismiss" }).effects).toEqual(closed(3, 100, "before a")) +}) + +test("an open whose signal aborted neither mounts nor replaces, and its caller hears onClose", () => { + const before = run(createDialogStackState(), push("a")) + const next = transitionDialogStack(before.state, open("show", "b", true)) + + expect(next.state).toBe(before.state) + expect(next.effects).toEqual([{ type: "discard", request: "b", notify: true }]) +}) + +describe("exit timers and disposal", () => { + test.each<[string, Event[]]>([ + ["an open dialog", [push("a")]], + ["a dialog already gone", [push("a"), { type: "dismiss" }, { type: "exit.completed", attempt: 1 }]], + ["a replaced dialog", [push("a"), { type: "dismiss" }, show("b")]], + ])("ignore a late exit for %s", (_, events) => { + const before = run(createDialogStackState(), ...events) + const next = transitionDialogStack(before.state, { type: "exit.completed", attempt: 1 }) + + expect(next.state).toBe(before.state) + expect(next.effects).toEqual([]) + }) + + test("a longer exit asked for after the close starts does not change the running timer", () => { + const before = run(createDialogStackState(), push("a"), { type: "dismiss" }) + const next = transitionDialogStack(before.state, { type: "layer.exit-duration", attempt: 1, exitMs: 960 }) + + expect(next.state).toBe(before.state) + }) + + test("the provider going away stops exit timers, disposes every dialog silently and ignores what follows", () => { + const before = run(createDialogStackState(), push("a"), push("b"), { type: "dismiss" }) + const gone = transitionDialogStack(before.state, { type: "disposed" }) + + expect(gone.effects).toEqual([ + { type: "dispose", attempt: 1, notify: false }, + { type: "timer.stop", attempt: 2 }, + { type: "dispose", attempt: 2, notify: false }, + ]) + expect(selectTopDialog(gone.state)).toBeUndefined() + expect(selectLayerClosing(gone.state, 1)).toBe(true) + + const late = [ + { type: "dismiss" }, + { type: "close" }, + { type: "exit.completed", attempt: 2 }, + { type: "disposed" }, + ] satisfies Event[] + + late.forEach((event) => { + const next = transitionDialogStack(gone.state, event) + + expect(next.state).toBe(gone.state) + expect(next.effects).toEqual([]) + }) + expect(transitionDialogStack(gone.state, push("c")).effects).toEqual([ + { type: "discard", request: "c", notify: false }, + ]) + expect(transitionDialogStack(gone.state, open("push", "c", true)).effects).toEqual([ + { type: "discard", request: "c", notify: true }, + ]) + }) +}) diff --git a/packages/ui/src/context/dialog-machine.ts b/packages/ui/src/context/dialog-machine.ts new file mode 100644 index 00000000000..2bf4288cd06 --- /dev/null +++ b/packages/ui/src/context/dialog-machine.ts @@ -0,0 +1,280 @@ +/** How long a dialog stays mounted once it starts closing, unless its layer asks for longer. */ +export const DIALOG_EXIT_MS = 100 + +/** + * `attempt` identifies one mount, so a reused caller `id` never collides with a layer that is still closing. `focus` is + * where focus returns: where it was before this dialog opened, or before the dialogs it replaced opened. `replaced` + * holds the attempts of the open dialogs this one replaced through `show`, and theirs in turn, so a close from inside + * one of them closes this dialog. + */ +export type DialogOpenEntry = { + readonly status: "open" + readonly attempt: number + readonly id: string + readonly exitMs: number + readonly backdropDismiss: boolean + readonly focus: F | undefined + readonly replaced: readonly number[] +} + +/** Waits for its exit animation. It keeps `focus` so a `show` that replaces it still returns focus to the origin. */ +export type DialogClosingEntry = { + readonly status: "closing" + readonly attempt: number + readonly id: string + readonly focus: F | undefined + readonly replaced: readonly number[] +} + +export type DialogEntry = DialogOpenEntry | DialogClosingEntry + +export type DialogStackState = + | { readonly status: "active"; readonly issued: number; readonly entries: readonly DialogEntry[] } + | { readonly status: "disposed"; readonly issued: number } + +/** `request` is the driver's content for the open; the machine only hands it back in `mount` or `discard`. */ +export type DialogStackEvent = + | { + readonly type: "open" + readonly mode: "show" | "push" + readonly id: string + readonly aborted: boolean + readonly focus: F | undefined + readonly request: R + } + /** + * With `id`, closes the newest open dialog with that id. Without one, `layer` is the attempt of the dialog that asked: + * that dialog closes itself, even under a dialog that is still exiting, or the dialog that replaced it through `show`. + * Once that dialog is gone, a late close (after an await) closes nothing. A close from outside every dialog closes the + * newest dialog. Both close one at a time: while the target plays its exit animation, a second close (a double click, + * a callback closing again) closes nothing below it. + */ + | { readonly type: "close"; readonly id?: string; readonly layer?: number } + /** Escape, or a dismissal that applies only while `id` is the top open dialog. */ + | { readonly type: "dismiss"; readonly id?: string } + /** A click on one layer's backdrop. */ + | { readonly type: "backdrop.click"; readonly attempt: number } + /** Kobalte asking one layer to close, as its close button does. */ + | { readonly type: "layer.dismiss"; readonly attempt: number } + | { readonly type: "layer.backdrop-dismiss"; readonly attempt: number; readonly enabled: boolean } + | { readonly type: "layer.exit-duration"; readonly attempt: number; readonly exitMs: number } + | { readonly type: "exit.completed"; readonly attempt: number } + | { readonly type: "disposed" } + +export type DialogStackEffect = + | { readonly type: "mount"; readonly attempt: number; readonly id: string; readonly request: R } + | { readonly type: "discard"; readonly request: R; readonly notify: boolean } + | { readonly type: "timer.start"; readonly attempt: number; readonly delayMs: number } + | { readonly type: "timer.stop"; readonly attempt: number } + | { readonly type: "notify.close"; readonly attempt: number } + | { readonly type: "focus.return"; readonly attempt: number; readonly focus: F | undefined } + | { readonly type: "dispose"; readonly attempt: number; readonly notify: boolean } + +export type DialogStackTransition = { + readonly state: DialogStackState + readonly effects: readonly DialogStackEffect[] +} + +export function createDialogStackState(): DialogStackState { + return { status: "active", issued: 0, entries: [] } +} + +export function transitionDialogStack( + state: DialogStackState, + event: DialogStackEvent, +): DialogStackTransition { + if (event.type === "open") return open(state, event) + + if (state.status === "disposed") return { state, effects: [] } + + if (event.type === "disposed") { + return { + state: { status: "disposed", issued: state.issued }, + effects: state.entries.flatMap((entry) => teardown(entry, false)), + } + } + + if (event.type === "exit.completed") { + const entry = state.entries.find((item) => item.attempt === event.attempt) + + if (entry?.status !== "closing") return { state, effects: [] } + + return { + state: { ...state, entries: state.entries.filter((item) => item !== entry) }, + effects: [{ type: "dispose", attempt: entry.attempt, notify: false }], + } + } + + if (event.type === "layer.backdrop-dismiss") { + return update(state, event.attempt, (entry) => + entry.backdropDismiss === event.enabled ? entry : { ...entry, backdropDismiss: event.enabled }, + ) + } + + if (event.type === "layer.exit-duration") { + const exitMs = Math.max(0, event.exitMs) + + return update(state, event.attempt, (entry) => (entry.exitMs === exitMs ? entry : { ...entry, exitMs })) + } + + const target = closeTarget(state, event) + + if (!target) return { state, effects: [] } + + return beginClose(state, target) +} + +/** The top dialog that is open. One that started closing no longer counts, though it waits to be disposed. */ +export function selectTopDialog(state: DialogStackState) { + if (state.status === "disposed") return undefined + + return state.entries.findLast((entry): entry is DialogOpenEntry => entry.status === "open") +} + +/** True from the moment a layer starts closing, through its exit animation, and once it is gone. */ +export function selectLayerClosing(state: DialogStackState, attempt: number) { + if (state.status === "disposed") return true + + return state.entries.find((entry) => entry.attempt === attempt)?.status !== "open" +} + +/** Stacked dialogs render as sibling portals, so only the top open layer may own the focus trap. */ +export function selectLayerModal(state: DialogStackState, attempt: number, contained: boolean) { + return !contained && selectTopDialog(state)?.attempt === attempt +} + +/** The layer's place in the stack, so a newer dialog always renders above. */ +export function selectLayerIndex(state: DialogStackState, attempt: number) { + if (state.status === "disposed") return 0 + + return Math.max( + 0, + state.entries.findIndex((entry) => entry.attempt === attempt), + ) +} + +function open( + state: DialogStackState, + event: Extract, { type: "open" }>, +): DialogStackTransition { + // An open whose signal aborted neither mounts nor replaces anything; its caller hears onClose as a replaced one would. + if (event.aborted) return { state, effects: [{ type: "discard", request: event.request, notify: true }] } + + // A deferred open must not mount after the provider is gone. + if (state.status === "disposed") return { state, effects: [{ type: "discard", request: event.request, notify: false }] } + const attempt = state.issued + 1 + const replace = event.mode === "show" + const first = state.entries[0] + + const entry: DialogOpenEntry = { + status: "open", + attempt, + id: event.id, + exitMs: DIALOG_EXIT_MS, + backdropDismiss: true, + // A replacement returns focus to where the dialogs it replaces would have, not to their now-removed content. + focus: replace && first ? first.focus : event.focus, + // A dialog that had already started closing was not replaced: a late close from inside it still closes nothing. + replaced: replace + ? state.entries.flatMap((item) => (item.status === "open" ? [item.attempt, ...item.replaced] : [])) + : [], + } + + const mount: DialogStackEffect = { type: "mount", attempt, id: event.id, request: event.request } + + if (!replace) return { state: { ...state, issued: attempt, entries: [...state.entries, entry] }, effects: [mount] } + + return { + state: { ...state, issued: attempt, entries: [entry] }, + effects: [...state.entries.flatMap((item) => teardown(item, true)), mount], + } +} + +function closeTarget( + state: Extract, { status: "active" }>, + event: Extract< + DialogStackEvent, + { type: "close" } | { type: "dismiss" } | { type: "backdrop.click" } | { type: "layer.dismiss" } + >, +) { + const top = selectTopDialog(state) + + if (event.type === "close") { + if (event.id !== undefined) { + return state.entries.findLast( + (entry): entry is DialogOpenEntry => entry.status === "open" && entry.id === event.id, + ) + } + + const layer = event.layer + + const target = + layer === undefined + ? state.entries.at(-1) + : state.entries.find((entry) => entry.attempt === layer || entry.replaced.includes(layer)) + + return target?.status === "open" ? target : undefined + } + + if (event.type === "dismiss") return event.id === undefined || top?.id === event.id ? top : undefined + + if (top?.attempt !== event.attempt) return undefined + + if (event.type === "backdrop.click" && !top.backdropDismiss) return undefined + + return top +} + +/** The exit timer starts first, so the dialog still goes away when its onClose throws. */ +function beginClose( + state: Extract, { status: "active" }>, + target: DialogOpenEntry, +): DialogStackTransition { + // Only the top open dialog holds focus. It returns after onClose, so focus that onClose moved elsewhere stays there, + // and before close() returns, as a native dialog's does, so an action that runs after closing can move it on. + const top = selectTopDialog(state)?.attempt === target.attempt + + const closing: DialogClosingEntry = { + status: "closing", + attempt: target.attempt, + id: target.id, + focus: target.focus, + replaced: target.replaced, + } + + return { + state: { ...state, entries: state.entries.map((entry) => (entry === target ? closing : entry)) }, + effects: [ + { type: "timer.start", attempt: target.attempt, delayMs: target.exitMs }, + { type: "notify.close", attempt: target.attempt }, + ...(top ? [{ type: "focus.return" as const, attempt: target.attempt, focus: target.focus }] : []), + ], + } +} + +/** A dialog that is already closing heard onClose when it started to; it does not hear it again. */ +function teardown(entry: DialogEntry, notify: boolean): DialogStackEffect[] { + if (entry.status === "open") return [{ type: "dispose", attempt: entry.attempt, notify }] + + return [ + { type: "timer.stop", attempt: entry.attempt }, + { type: "dispose", attempt: entry.attempt, notify: false }, + ] +} + +function update( + state: Extract, { status: "active" }>, + attempt: number, + change: (entry: DialogOpenEntry) => DialogOpenEntry, +): DialogStackTransition { + const entry = state.entries.find( + (item): item is DialogOpenEntry => item.attempt === attempt && item.status === "open", + ) + + if (!entry) return { state, effects: [] } + const next = change(entry) + + if (next === entry) return { state, effects: [] } + + return { state: { ...state, entries: state.entries.map((item) => (item === entry ? next : item)) }, effects: [] } +} diff --git a/packages/ui/src/context/dialog.tsx b/packages/ui/src/context/dialog.tsx index 6e2a3cb167f..2c7ff1c43c4 100644 --- a/packages/ui/src/context/dialog.tsx +++ b/packages/ui/src/context/dialog.tsx @@ -1,6 +1,8 @@ import { + type Accessor, createContext, createEffect, + createMemo, createRoot, createSignal, getOwner, @@ -8,6 +10,7 @@ import { type Owner, type ParentProps, runWithOwner, + untrack, useContext, type JSX, startTransition, @@ -15,23 +18,32 @@ import { } from "solid-js" import { Dialog as Kobalte } from "@kobalte/core/dialog" import { makeEventListener } from "@solid-primitives/event-listener" +import { uuid } from "@opencode/util/uuid" +import { + createDialogStackState, + selectLayerClosing, + selectLayerIndex, + selectLayerModal, + selectTopDialog, + transitionDialogStack, + type DialogStackEffect, + type DialogStackEvent, +} from "./dialog-machine" type DialogElement = () => JSX.Element -type FocusReturn = { element: HTMLElement; visible: boolean; range?: Range } +export type FocusReturn = { element: HTMLElement; visible: boolean; range?: Range } -type Active = { - id: string +/** What an open mounts: its content, the owner it renders under, and who hears that it closed. */ +type DialogRequest = { element: DialogElement; owner: Owner; onClose?: () => void } + +type Layer = { + attempt: number node: JSX.Element - dispose: () => void owner: Owner onClose?: () => void - setClosing: (closing: boolean) => void - /** How long the dialog stays mounted once it starts closing, so its exit animation can finish. */ - exit: () => number - /** Where focus was before this dialog opened, or before the dialogs it replaced opened. */ - focus?: FocusReturn - returnFocus: () => void + dispose: () => void + ref: () => HTMLDivElement | undefined } const Context = createContext>() @@ -39,6 +51,11 @@ const Context = createContext>() // Lets the dialog rendered in a layer opt out of closing on a backdrop click, or ask for a longer exit animation. A // contained layer also says which element holds it, so presses outside that element leave the dialog open. const LayerContext = createContext<{ + readonly id: string + /** This layer's mount, which a `close()` from inside it targets. */ + readonly attempt: number + /** True from the moment this dialog starts closing, through its exit animation. */ + readonly closing: Accessor setBackdropDismiss: (value: boolean) => void setExitDuration: (ms: number) => void container?: HTMLElement @@ -49,154 +66,136 @@ export function useDialogLayer() { } function init(container: () => HTMLElement | undefined) { - const [stack, setStack] = createSignal([]) - // A dialog is closing from the moment its close starts until its exit animation ends and it is disposed. - const closing = new Map | undefined>() - // The same ids, reactive, so the top dialog that stays open owns the focus trap during an exit animation. - const [exiting, setExiting] = createSignal>(new Set()) - // The top dialog that stays open. A dialog without an exit animation leaves the DOM as soon as it starts closing, so - // it stops being the active dialog then, not when it is disposed. - const top = () => stack().findLast((item) => !exiting().has(item.id)) - const lock = { value: false } - const state = { disposed: false } + const [machine, setMachine] = createSignal(createDialogStackState()) + const [layers, setLayers] = createSignal([]) + const timers = new Map>() + // Events an effect raises synchronously (a dialog closing as it renders or disposes) wait behind it. + const queue: DialogStackEvent[] = [] - // Detach the stack before disposing, so cleanups that close dialogs find nothing to admit. Every dialog is - // drained even when one throws. A replaced dialog that was not already closing still hears onClose. - const disposeAll = (notify: boolean) => { - const items = stack() - const exited = new Set(closing.keys()) - setStack([]) - closing.forEach((timer) => clearTimeout(timer)) - closing.clear() - setExiting(new Set()) - items.forEach((item) => { - if (notify && !exited.has(item.id)) isolate(() => item.onClose?.()) - isolate(item.dispose) - }) + const dispatch = (event: DialogStackEvent) => { + queue.push(event) + + if (queue.length === 1) untrack(drain) } - onCleanup(() => { - state.disposed = true - disposeAll(false) - }) + const drain = () => { + const event = queue[0] - const finish = (current: Active) => { - // Scheduled first, so the dialog still goes away when a callback throws. - closing.set( - current.id, - setTimeout(() => { - closing.delete(current.id) + if (!event) return - if (closing.size === 0) lock.value = false - setExiting((ids) => new Set([...ids].filter((id) => id !== current.id))) - setStack((items) => items.filter((item) => item.id !== current.id)) - current.dispose() - }, current.exit()), - ) - setExiting((ids) => new Set([...ids, current.id])) - isolate(() => current.onClose?.()) - current.setClosing(true) + try { + const prev = machine() + const next = transitionDialogStack(prev, event) - // Only the top open dialog holds focus. It returns before close() does, as a native dialog's does, so an - // action that runs after closing, such as a palette command that opens the terminal, can move it on. - if (stack().findLast((item) => item === current || !closing.has(item.id)) === current) current.returnFocus() + // Committed before the effects, so a closing layer's Kobalte dialog has closed by the time focus returns. A reader + // of the state or an effect that throws must not stop the queue or skip the other effects. + if (next.state !== prev) isolate(() => setMachine(next.state)) + next.effects.forEach((effect) => isolate(() => run(effect))) + } finally { + queue.shift() + drain() + } } - /** Programmatic close. Without an id it closes the top dialog, one at a time; with an id it never waits. */ - const close = (id?: string) => { - const current = id ? stack().find((item) => item.id === id) : stack().at(-1) + const run = (effect: DialogStackEffect) => { + if (effect.type === "mount") return mount(effect) - if (!current || closing.has(current.id) || (!id && lock.value)) return - closing.set(current.id, undefined) - lock.value = true - finish(current) + if (effect.type === "discard") return void (effect.notify && effect.request.onClose?.()) + + if (effect.type === "timer.start") { + clearTimeout(timers.get(effect.attempt)) + timers.set( + effect.attempt, + setTimeout(() => dispatch({ type: "exit.completed", attempt: effect.attempt }), effect.delayMs), + ) + + return + } + + if (effect.type === "timer.stop") { + clearTimeout(timers.get(effect.attempt)) + timers.delete(effect.attempt) + + return + } + + const layer = layers().find((item) => item.attempt === effect.attempt) + + if (effect.type === "notify.close") return layer?.onClose?.() + + if (effect.type === "focus.return") { + const ref = layer?.ref() + + // A close inside a reactive update unmounts the dialog, and its focus trap, only when the update ends. + if (ref?.contains(document.activeElement)) return queueMicrotask(() => returnFocus(effect.focus, ref)) + + return returnFocus(effect.focus, ref) + } + + timers.delete(effect.attempt) + setLayers((items) => items.filter((item) => item.attempt !== effect.attempt)) + + if (effect.notify) isolate(() => layer?.onClose?.()) + layer?.dispose() } - /** Escape, a backdrop click, or Kobalte dismissing: only the top dialog, and one per exit animation. */ - const dismiss = (id?: string) => { - const current = stack().at(-1) + onCleanup(() => dispatch({ type: "disposed" })) - if (!current || (id && current.id !== id) || closing.has(current.id) || lock.value) return - closing.set(current.id, undefined) - lock.value = true - finish(current) + // Escape is captured only while a dialog is open, not while the last one plays its exit animation. + const open = createMemo(() => !!selectTopDialog(machine())) + + const onKeyDown = (event: KeyboardEvent) => { + if (event.key !== "Escape") return + + // Escape in the page around a contained stack belongs to the page. + const within = container() + + if (within && event.target instanceof Node && !within.contains(event.target)) return + + // A control that cancels its own edit on Escape, such as an inline rename, keeps the dialog open. + if (event.target instanceof Element && event.target.closest("[data-owns-escape]")) return + dispatch({ type: "dismiss" }) + event.preventDefault() + event.stopPropagation() } createEffect(() => { - if (stack().length === 0) return - - const onKeyDown = (event: KeyboardEvent) => { - if (event.key !== "Escape") return - - // Escape in the page around a contained stack belongs to the page. - const within = container() - - if (within && event.target instanceof Node && !within.contains(event.target)) return - - // A control that cancels its own edit on Escape, such as an inline rename, keeps the dialog open. - if (event.target instanceof Element && event.target.closest("[data-owns-escape]")) return - dismiss() - event.preventDefault() - event.stopPropagation() - } + if (!open()) return makeEventListener(window, "keydown", onKeyDown, { capture: true }) }) - const mount = ( - element: DialogElement, - owner: Owner, - onClose: (() => void) | undefined, - key: string | undefined, - focus: FocusReturn | undefined, - ) => { - // A deferred open (e.g. from a focus callback) must not mount after the provider is gone. - if (state.disposed) return - const id = key ?? Math.random().toString(36).slice(2) - - // The layer follows the dialog's current place in the stack, so a new top dialog always renders above. - const layer = () => - Math.max( - 0, - stack().findIndex((item) => item.id === id), - ) - - const zIndex = () => String(50 + layer() * 10) + const mount = (effect: Extract, { type: "mount" }>) => { + const attempt = effect.attempt + const zIndex = () => String(50 + selectLayerIndex(machine(), attempt) * 10) // A function, not an inline `&&`: the compiler wraps an inline condition in a memo on every read of the prop, and // Kobalte reads it outside any owner, from outside-pointer handlers and while the closing dialog unmounts. - const modal = () => !container() && top()?.id === id - let dispose: (() => void) | undefined - let setClosing: ((closing: boolean) => void) | undefined - let layerRef: HTMLDivElement | undefined - let exit = 100 + const modal = () => selectLayerModal(machine(), attempt, !!container()) + let ref: HTMLDivElement | undefined + let dispose = () => {} - // Stacked dialogs render as sibling portals, so only the top layer may own the focus trap. - const node = runWithOwner(owner, () => + const node = runWithOwner(effect.request.owner, () => createRoot((d: () => void) => { dispose = d - const [closing, setClosingSignal] = createSignal(false) - const [backdropDismiss, setBackdropDismiss] = createSignal(true) - setClosing = setClosingSignal + const closing = createMemo(() => selectLayerClosing(machine(), attempt)) return ( { - if (!open) dismiss(id) + if (!open) dispatch({ type: "layer.dismiss", attempt }) }} > { - if (backdropDismiss()) dismiss(id) - }} + onClick={() => dispatch({ type: "backdrop.click", attempt })} />
HTMLElement | undefined) { }} > (exit = ms), container: container() }} + value={{ + id: effect.id, + attempt, + closing, + setBackdropDismiss: (enabled) => dispatch({ type: "layer.backdrop-dismiss", attempt, enabled }), + setExitDuration: (exitMs) => dispatch({ type: "layer.exit-duration", attempt, exitMs }), + container: container(), + }} > - {element()} + {effect.request.element()}
@@ -219,56 +225,33 @@ function init(container: () => HTMLElement | undefined) { }), ) - if (!dispose || !setClosing) return - - const active: Active = { - id, - node, - dispose, - owner, - onClose, - setClosing, - exit: () => exit, - focus, - returnFocus: () => { - // A close inside a reactive update unmounts the dialog, and its focus trap, only when the update ends. - if (layerRef?.contains(document.activeElement)) return queueMicrotask(() => returnFocus(focus, layerRef)) - returnFocus(focus, layerRef) + setLayers((items) => [ + ...items, + { + attempt, + node, + owner: effect.request.owner, + onClose: effect.request.onClose, + dispose, + ref: () => ref, }, - } - - setStack((items) => [...items, active]) - } - - const push = (element: DialogElement, owner: Owner, onClose?: () => void, id?: string) => { - lock.value = false - mount(element, owner, onClose, id, captureFocus()) - } - - const show = (element: DialogElement, owner: Owner, onClose?: () => void, id?: string) => { - // A replacement returns focus to where the dialogs it replaces would have, not to their now-removed content. - const focus = stack().length > 0 ? stack()[0].focus : captureFocus() - disposeAll(true) - lock.value = false - mount(element, owner, onClose, id, focus) + ]) } return { - stack, - top, - close, - show, - push, + dispatch, + active: () => selectTopDialog(machine()), + /** Stacked dialogs render under the owner of the dialog below, so they see the same context. */ + base: () => layers().at(-1)?.owner, + open: (mode: "show" | "push", request: DialogRequest, id: string | undefined, aborted: boolean) => + dispatch({ type: "open", mode, id: id ?? uuid(), aborted, focus: captureFocus(), request }), + layers, } } /** Runs a dialog callback so its throw is reported without stopping the caller's cleanup. */ function isolate(fn: () => void) { - try { - fn() - } catch (error) { - console.error("[dialog]", error) - } + void Promise.try(fn).catch((cause: unknown) => console.error("[dialog]", cause)) } /** Remembers the focused element and, in editable content, the caret, which focusing alone does not restore. */ @@ -314,7 +297,7 @@ export function DialogProvider(props: ParentProps<{ container?: HTMLElement }>) {props.children}
- {(item) => item.node} + {(item) => item.node}
) @@ -322,6 +305,7 @@ export function DialogProvider(props: ParentProps<{ container?: HTMLElement }>) export function useDialog() { const ctx = useContext(Context) + const layer = useContext(LayerContext) const owner = getOwner() if (!owner) { @@ -335,30 +319,37 @@ export function useDialog() { return { /** The top dialog that is open. One that has started closing no longer counts, though it waits to be disposed. */ get active() { - return ctx.top() + return ctx.active() + }, + /** Inside a dialog, true from the moment that dialog starts closing; outside every dialog, false. */ + get closing() { + return layer?.closing() ?? false }, /** * id lets the caller close this dialog later rather than whichever is on top. Opening is deferred; once * signal aborts, the open neither mounts nor replaces anything and onClose runs as for a replaced dialog. */ show(element: DialogElement, onClose?: () => void, id?: string, signal?: AbortSignal) { - const base = ctx.stack().at(-1)?.owner ?? owner + const base = ctx.base() ?? owner - return startTransition(() => { - if (signal?.aborted) return isolate(() => onClose?.()) - ctx.show(element, base, onClose, id) - }) + return startTransition(() => ctx.open("show", { element, owner: base, onClose }, id, !!signal?.aborted)) }, push(element: DialogElement, onClose?: () => void, id?: string, signal?: AbortSignal) { - const base = ctx.stack().at(-1)?.owner ?? owner + const base = ctx.base() ?? owner - return startTransition(() => { - if (signal?.aborted) return isolate(() => onClose?.()) - ctx.push(element, base, onClose, id) - }) + return startTransition(() => ctx.open("push", { element, owner: base, onClose }, id, !!signal?.aborted)) }, + /** + * Programmatic close. With an id it closes that dialog at once. Without one, called inside a dialog, it closes that + * dialog, or the dialog that replaced it through `show`, and nothing once it is gone; outside every dialog it closes + * the top one. Either way one at a time, so a double click closes one dialog. + */ close(id?: string) { - ctx.close(id) + ctx.dispatch({ type: "close", id, layer: layer?.attempt }) + }, + /** Dismisses the top open dialog, as Escape does; with an id, only while that dialog is on top. */ + dismiss(id?: string) { + ctx.dispatch({ type: "dismiss", id }) }, } } diff --git a/packages/ui/src/overlays/dialog/dialog.stories.tsx b/packages/ui/src/overlays/dialog/dialog.stories.tsx index d49191251fe..8169aba2cb2 100644 --- a/packages/ui/src/overlays/dialog/dialog.stories.tsx +++ b/packages/ui/src/overlays/dialog/dialog.stories.tsx @@ -1,8 +1,8 @@ import { Overlay, Portal, Root, Trigger } from "@kobalte/core/dialog" import { Dialog, DialogBody, DialogFooter, DialogHeader, DialogTitle, DialogTitleGroup } from "./dialog" import { Button } from "@opencode/ui/button" -import { useDialog } from "@opencode/ui/context/dialog" -import { onMount, type JSX } from "solid-js" +import { useDialog, useDialogLayer } from "@opencode/ui/context/dialog" +import { onMount, type JSX, type ParentProps } from "solid-js" const docs = `### Overview Dialog content wrapper built on Kobalte's dialog primitive with v2 styling. @@ -229,3 +229,57 @@ function OpenFromButton() { export const OpenedFromButton = { render: () => , } + +// Stays mounted as long as an image preview's flight out, so its exit outlasts the dialogs above it. +function SlowExit(props: ParentProps) { + useDialogLayer()?.setExitDuration(960) + + return props.children +} + +function StackedDialogs() { + const dialog = useDialog() + + const open = () => { + void dialog.show(() => ( + + {dialogHeader("Below", "The first dialog in the stack")} + Stays open throughout. + + )) + void dialog.push( + () => ( + + + {dialogHeader("Middle", "Takes 960 ms to leave, as an image preview does")} + Closed by its id while it is not on top. + + + ), + undefined, + "middle", + ) + void dialog.push(() => ( + + {dialogHeader("Top", "Close the middle dialog, then press Escape")} + + + + + )) + } + + onMount(open) + + return ( + + ) +} + +export const Stacked = { + render: () => , +} diff --git a/packages/ui/src/overlays/dialog/dialog.tsx b/packages/ui/src/overlays/dialog/dialog.tsx index d6f2adbb03a..38193d0e575 100644 --- a/packages/ui/src/overlays/dialog/dialog.tsx +++ b/packages/ui/src/overlays/dialog/dialog.tsx @@ -6,6 +6,7 @@ import { Show, children, createEffect, + onCleanup, splitProps, } from "solid-js" import { useDialogLayer } from "../../context/dialog" @@ -113,7 +114,9 @@ export function Dialog(props: DialogProps) { ]) const layer = useDialogLayer() + let focusTimer: ReturnType | undefined createEffect(() => layer?.setBackdropDismiss(!local.preventBackdropDismiss)) + onCleanup(() => clearTimeout(focusTimer)) return (
{ + clearTimeout(focusTimer) + focusTimer = setTimeout(() => { + // A dialog that closed in the meantime must not pull focus back from where its close returned it. + if (layer?.closing() || !content.isConnected) return const autofocus = content.querySelector("[autofocus]") const active = document.activeElement