fix(session-ui): keep the newest Mermaid diagram when renders finish out of order (#61821)

This commit is contained in:
Luke Parker
2026-11-04 18:05:37 -06:00
committed by GitHub
Unverified
parent 71f1ad16e4
commit fa34b0e095
3 changed files with 562 additions and 152 deletions
@@ -0,0 +1,229 @@
import { describe, expect, test } from "bun:test"
import {
EMPTY_CODE_EFFECTS,
INITIAL_CODE_DECORATION_STATE,
transitionCodeDecoration,
viewCodeDecoration,
type CodeDecorationEvent,
type CodeDecorationState,
} from "./markdown-code-machine"
const sync = (source: string, complete: boolean, language = "mermaid") =>
({ type: "sync", language, source, complete, match: undefined }) as const
function run(events: CodeDecorationEvent[], state = INITIAL_CODE_DECORATION_STATE) {
return events.reduce(
(result, event) => {
const next = transitionCodeDecoration(result.state, event)
return { state: next.state, effects: next.effects }
},
{ state, effects: EMPTY_CODE_EFFECTS },
)
}
function svg(state: CodeDecorationState) {
return viewCodeDecoration(state).svg
}
const claim = (language: string) => ({ render: new Set([language]), actions: new Set<string>() })
describe("markdown code decoration", () => {
test("keeps plain code on the same state with no effects", () => {
const match = claim("python")
const first = transitionCodeDecoration(INITIAL_CODE_DECORATION_STATE, {
type: "sync",
language: "ts",
source: "const a",
complete: false,
match,
})
const second = transitionCodeDecoration(first.state, {
type: "sync",
language: "ts",
source: "const a = 1",
complete: false,
match,
})
expect(first.state).toBe(INITIAL_CODE_DECORATION_STATE)
expect(second.state).toBe(INITIAL_CODE_DECORATION_STATE)
expect(second.effects).toBe(EMPTY_CODE_EFFECTS)
})
test("ignores a slow render of earlier streamed lines once a newer diagram rendered", () => {
const started = run([sync("flowchart LR\nA --> B\n", false), sync("flowchart LR\nA --> B\nB --> C", true)])
expect(started.effects).toEqual([{ type: "render-mermaid", attempt: 2, input: "flowchart LR\nA --> B\nB --> C" }])
const newer = transitionCodeDecoration(started.state, { type: "mermaid.resolved", attempt: 2, svg: "<svg>2</svg>" })
const older = transitionCodeDecoration(newer.state, { type: "mermaid.resolved", attempt: 1, svg: "<svg>1</svg>" })
expect(svg(newer.state)).toBe("<svg>2</svg>")
expect(older.state).toBe(newer.state)
expect(older.effects).toBe(EMPTY_CODE_EFFECTS)
})
test("renders a replaced diagram of the same length", () => {
const ready = run([
sync("flowchart LR\nA --> B", true),
{ type: "mermaid.resolved", attempt: 1, svg: "<svg>1</svg>" },
])
const replaced = transitionCodeDecoration(ready.state, sync("flowchart TD\nX --> Y", true))
expect(replaced.effects).toEqual([{ type: "render-mermaid", attempt: 2, input: "flowchart TD\nX --> Y" }])
expect(svg(replaced.state)).toBe("<svg>1</svg>")
})
test("shows the empty diagram box until the first line ends, then renders whole lines once", () => {
const first = run([sync("flowchart LR", false)])
expect(viewCodeDecoration(first.state).pending).toBe(true)
expect(first.effects).toEqual([])
const line = transitionCodeDecoration(first.state, sync("flowchart LR\nA", false))
const token = transitionCodeDecoration(line.state, sync("flowchart LR\nA -", false))
expect(line.effects).toEqual([{ type: "render-mermaid", attempt: 1, input: "flowchart LR\n" }])
expect(token.state).toBe(line.state)
})
test("shows the code when a streamed diagram fails, and renders the next lines behind it", () => {
const failed = run([sync("invalid\n", false), { type: "mermaid.failed", attempt: 1 }])
expect(failed.state.status).toBe("code")
expect(viewCodeDecoration(failed.state).pending).toBe(false)
expect(transitionCodeDecoration(failed.state, sync("invalid\nmore", false)).state).toBe(failed.state)
const retry = transitionCodeDecoration(failed.state, sync("invalid\nflowchart LR\n", false))
expect(retry.state.status).toBe("code")
expect(retry.effects).toEqual([{ type: "render-mermaid", attempt: 2, input: "invalid\nflowchart LR\n" }])
const recovered = transitionCodeDecoration(retry.state, { type: "mermaid.resolved", attempt: 2, svg: "<svg />" })
expect(svg(recovered.state)).toBe("<svg />")
})
test("treats a render without output like a failure", () => {
const declined = run([sync("not a diagram", true), { type: "mermaid.resolved", attempt: 1, svg: undefined }])
expect(declined.state.status).toBe("code")
expect(transitionCodeDecoration(declined.state, sync("not a diagram", true)).state).toBe(declined.state)
})
test("keeps the last diagram while newer lines fail, and shows the code when the complete diagram fails", () => {
const ready = run([sync("flowchart LR\n", false), { type: "mermaid.resolved", attempt: 1, svg: "<svg>1</svg>" }])
const refreshing = transitionCodeDecoration(ready.state, sync("flowchart LR\nA[\n", false))
expect(viewCodeDecoration(refreshing.state)).toMatchObject({ pending: false, svg: "<svg>1</svg>" })
const kept = transitionCodeDecoration(refreshing.state, { type: "mermaid.failed", attempt: 2 })
expect(svg(kept.state)).toBe("<svg>1</svg>")
const complete = run([sync("flowchart LR\nA[", true), { type: "mermaid.failed", attempt: 3 }], kept.state)
expect(complete.state.status).toBe("code")
expect(viewCodeDecoration(complete.state).diagram).toBe(false)
})
test("ignores a Mermaid render that finishes after a plugin claimed the block", () => {
const match = claim("mermaid")
const pending = run([sync("flowchart LR\nA --> B\n", false)])
const plugin = transitionCodeDecoration(pending.state, {
type: "sync",
language: "mermaid",
source: "flowchart LR\nA --> B\n",
complete: true,
match,
})
expect(plugin.effects).toEqual([
{ type: "mount-plugin", attempt: 2, block: { code: "flowchart LR\nA --> B", language: "mermaid" } },
])
const late = transitionCodeDecoration(plugin.state, { type: "mermaid.resolved", attempt: 1, svg: "<svg />" })
expect(late.state).toBe(plugin.state)
expect(viewCodeDecoration(plugin.state)).toMatchObject({ content: true, svg: undefined })
const fallback = transitionCodeDecoration(plugin.state, { type: "plugin.failed", attempt: 2 })
expect(fallback.state.status).toBe("diagram-pending")
expect(fallback.effects).toEqual([
{ type: "clear-plugin" },
{ type: "render-mermaid", attempt: 3, input: "flowchart LR\nA --> B\n" },
])
})
test("keeps the code after plugin content fails until the block changes", () => {
const match = claim("chart")
const event = { type: "sync", language: "chart", source: "x", complete: true, match } as const
const mounted = transitionCodeDecoration(INITIAL_CODE_DECORATION_STATE, event)
const failed = transitionCodeDecoration(mounted.state, { type: "plugin.failed", attempt: 1 })
const stale = transitionCodeDecoration(failed.state, { type: "plugin.failed", attempt: 1 })
expect(failed.state.status).toBe("code")
expect(stale.state).toBe(failed.state)
expect(transitionCodeDecoration(failed.state, event).state).toBe(failed.state)
expect(transitionCodeDecoration(failed.state, { ...event, source: "y" }).effects).toEqual([
{ type: "mount-plugin", attempt: 2, block: { code: "y", language: "chart" } },
])
})
test("waits for the closing fence before mounting claimed content", () => {
const match = claim("chart")
const streaming = transitionCodeDecoration(INITIAL_CODE_DECORATION_STATE, {
type: "sync",
language: "chart",
source: "x",
complete: false,
match,
})
expect(streaming.state).toBe(INITIAL_CODE_DECORATION_STATE)
})
test("mounts actions for a complete block and moves them when it changes", () => {
const match = { render: new Set<string>(), actions: new Set(["sql"]) }
const event = { type: "sync", language: "sql", source: "select 1\n", complete: true, match } as const
const mounted = transitionCodeDecoration(INITIAL_CODE_DECORATION_STATE, event)
expect(mounted.effects).toEqual([{ type: "mount-actions", block: { code: "select 1", language: "sql" } }])
expect(transitionCodeDecoration(mounted.state, event).state).toBe(mounted.state)
expect(transitionCodeDecoration(mounted.state, { ...event, match: undefined }).effects).toEqual([
{ type: "clear-actions" },
])
})
test("clears mounted content on dispose and ignores results that arrive later", () => {
const match = { render: new Set(["chart"]), actions: new Set(["chart"]) }
const mounted = transitionCodeDecoration(INITIAL_CODE_DECORATION_STATE, {
type: "sync",
language: "chart",
source: "x",
complete: true,
match,
})
const disposed = transitionCodeDecoration(mounted.state, { type: "disposed" })
expect(disposed.effects).toEqual([{ type: "clear-actions" }, { type: "clear-plugin" }])
expect(transitionCodeDecoration(disposed.state, { type: "plugin.failed", attempt: 1 }).state).toBe(disposed.state)
const pending = run([sync("flowchart LR\n", false), { type: "disposed" }])
expect(viewCodeDecoration(pending.state).diagram).toBe(false)
expect(
transitionCodeDecoration(pending.state, { type: "mermaid.resolved", attempt: 1, svg: "<svg />" }).state,
).toBe(pending.state)
})
test("leaves the diagram when the block stops being Mermaid", () => {
const pending = run([sync("flowchart LR\n", false)])
const code = transitionCodeDecoration(pending.state, sync("flowchart LR\n", false, "text"))
expect(code.state.status).toBe("code")
expect(transitionCodeDecoration(code.state, { type: "mermaid.resolved", attempt: 1, svg: "<svg />" }).state).toBe(
code.state,
)
})
})
@@ -0,0 +1,200 @@
import type { MarkdownCodeBlock, MarkdownCodeBlockMatch } from "../context/markdown"
/** A complete block as plugin content or actions received it; another key means the content must mount again. */
export type CodeBlockKey = {
readonly match: MarkdownCodeBlockMatch
readonly language: string
readonly source: string
}
/** What a Mermaid render draws: whole lines while the block streams, the full source once it is complete. */
export type MermaidInput = { readonly input: string; readonly complete: boolean }
export type MermaidRender = MermaidInput & { readonly attempt: number }
type Shared = {
/** Started renders and plugin mounts. A result whose attempt is not the current one is stale. */
readonly attempts: number
readonly actions?: CodeBlockKey
/** Plugin content that declined or failed for this exact block, so the block keeps its code until it changes. */
readonly declined?: CodeBlockKey
}
/**
* One fenced code block. `code` shows the highlighted source, `diagram-pending` the empty diagram box until the first
* Mermaid render lands, `diagram` the last good SVG, and `plugin` content a plugin mounted for the block's language.
* `render` is the Mermaid render in flight; `tried` is the input of the last one that settled, so the same input never
* renders twice.
*/
export type CodeDecorationState =
| (Shared & { readonly status: "code"; readonly render?: MermaidRender; readonly tried?: MermaidInput })
| (Shared & { readonly status: "diagram-pending"; readonly render?: MermaidRender })
| (Shared & {
readonly status: "diagram"
readonly svg: string
readonly render?: MermaidRender
readonly tried: MermaidInput
})
| (Shared & { readonly status: "plugin"; readonly plugin: CodeBlockKey })
export type CodeDecorationEvent =
| {
readonly type: "sync"
readonly language: string
readonly source: string
readonly complete: boolean
readonly match: MarkdownCodeBlockMatch | undefined
}
| { readonly type: "mermaid.resolved"; readonly attempt: number; readonly svg: string | undefined }
| { readonly type: "mermaid.failed"; readonly attempt: number }
| { readonly type: "plugin.failed"; readonly attempt: number }
| { readonly type: "disposed" }
export type CodeDecorationEffect =
| { readonly type: "clear-actions" }
| { readonly type: "clear-plugin" }
| { readonly type: "mount-actions"; readonly block: MarkdownCodeBlock }
| { readonly type: "mount-plugin"; readonly attempt: number; readonly block: MarkdownCodeBlock }
| { readonly type: "render-mermaid"; readonly attempt: number; readonly input: string }
export type CodeDecorationTransition = {
readonly state: CodeDecorationState
readonly effects: readonly CodeDecorationEffect[]
}
type Sync = Extract<CodeDecorationEvent, { type: "sync" }>
export const INITIAL_CODE_DECORATION_STATE: CodeDecorationState = Object.freeze({ status: "code", attempts: 0 })
export const EMPTY_CODE_EFFECTS: readonly CodeDecorationEffect[] = Object.freeze([])
export function transitionCodeDecoration(
state: CodeDecorationState,
event: CodeDecorationEvent,
): CodeDecorationTransition {
if (event.type === "sync") return settle(state, sync(state, event, state.declined))
if (event.type === "plugin.failed") {
if (state.status !== "plugin" || event.attempt !== state.attempts) return { state, effects: EMPTY_CODE_EFFECTS }
const plugin = state.plugin
return settle(state, sync(state, { type: "sync", ...plugin, complete: true }, plugin))
}
if (event.type === "disposed") return settle(state, { status: "code", attempts: state.attempts })
if (state.status === "plugin" || state.render?.attempt !== event.attempt)
return { state, effects: EMPTY_CODE_EFFECTS }
const render = state.render
const shared = { attempts: state.attempts, actions: state.actions, declined: state.declined }
if (event.type === "mermaid.resolved" && event.svg)
return settle(state, { ...shared, status: "diagram", svg: event.svg, tried: render })
// A partial diagram often fails until more lines arrive, so the last good one stays; a complete failure shows the code.
if (state.status === "diagram" && !render.complete)
return settle(state, { ...shared, status: "diagram", svg: state.svg, tried: render })
return settle(state, { ...shared, status: "code", tried: render })
}
export function viewCodeDecoration(state: CodeDecorationState) {
return {
diagram: state.status === "diagram-pending" || state.status === "diagram",
pending: state.status === "diagram-pending",
svg: state.status === "diagram" ? state.svg : undefined,
content: state.status === "plugin",
}
}
function sync(state: CodeDecorationState, event: Sync, declined: CodeBlockKey | undefined): CodeDecorationState {
const match = event.match
const claimed = !!match?.render.has(event.language)
const failed = declined && sameBlock(declined, event) ? declined : undefined
const actions =
!match || !event.complete || !match.actions.has(event.language)
? undefined
: state.actions && sameBlock(state.actions, event)
? state.actions
: { match, language: event.language, source: event.source }
if (match && claimed && event.complete && !failed) {
if (state.status === "plugin" && sameBlock(state.plugin, event)) return keep(state, actions, failed)
return {
status: "plugin",
attempts: state.attempts + 1,
plugin: { match, language: event.language, source: event.source },
actions,
}
}
// Claimed content waits for the closing fence and gets the code until then, not the built-in diagram.
if (event.language !== "mermaid" || !event.source || (claimed && !failed)) {
if (state.status === "code" && !state.render && !state.tried) return keep(state, actions, failed)
return { status: "code", attempts: state.attempts, actions, declined: failed }
}
const input = event.complete ? event.source : event.source.slice(0, event.source.lastIndexOf("\n") + 1)
if (state.status === "plugin" || (state.status === "code" && !state.render && !state.tried)) {
if (!input) return { status: "diagram-pending", attempts: state.attempts, actions, declined: failed }
const attempt = state.attempts + 1
return {
status: "diagram-pending",
attempts: attempt,
render: { attempt, input, complete: event.complete },
actions,
declined: failed,
}
}
const latest = state.render ?? (state.status === "diagram-pending" ? undefined : state.tried)
if (!input || (latest?.input === input && latest.complete === event.complete)) return keep(state, actions, failed)
const render = { attempt: state.attempts + 1, input, complete: event.complete }
return { ...state, attempts: render.attempt, render, actions, declined: failed }
}
function keep(state: CodeDecorationState, actions: CodeBlockKey | undefined, declined: CodeBlockKey | undefined) {
if (state.actions === actions && state.declined === declined) return state
return { ...state, actions, declined }
}
// Effects follow from the difference between the two states, so every transition mounts and clears the same way.
function settle(state: CodeDecorationState, next: CodeDecorationState): CodeDecorationTransition {
if (next === state) return { state, effects: EMPTY_CODE_EFFECTS }
const plugin = state.status === "plugin" ? state.attempts : undefined
const nextPlugin = next.status === "plugin" ? next : undefined
const render = state.status === "plugin" ? undefined : state.render
const nextRender = next.status === "plugin" ? undefined : next.render
const effects: CodeDecorationEffect[] = [
...(state.actions && state.actions !== next.actions ? [{ type: "clear-actions" as const }] : []),
...(plugin !== undefined && plugin !== nextPlugin?.attempts ? [{ type: "clear-plugin" as const }] : []),
...(next.actions && next.actions !== state.actions
? [{ type: "mount-actions" as const, block: block(next.actions) }]
: []),
...(nextPlugin && nextPlugin.attempts !== plugin
? [{ type: "mount-plugin" as const, attempt: nextPlugin.attempts, block: block(nextPlugin.plugin) }]
: []),
...(nextRender && nextRender !== render
? [{ type: "render-mermaid" as const, attempt: nextRender.attempt, input: nextRender.input }]
: []),
]
return { state: next, effects }
}
function block(key: CodeBlockKey): MarkdownCodeBlock {
return { code: key.source.replace(/\n$/, ""), language: key.language }
}
function sameBlock(key: CodeBlockKey, event: Pick<Sync, "match" | "language" | "source">) {
return key.match === event.match && key.language === event.language && key.source === event.source
}
+133 -152
View File
@@ -37,6 +37,13 @@ import {
type MarkdownCacheEntry,
} from "./markdown-cache"
import { inlineCodeKind } from "./markdown-inline-code-kind"
import {
INITIAL_CODE_DECORATION_STATE,
transitionCodeDecoration,
viewCodeDecoration,
type CodeDecorationEffect,
type CodeDecorationEvent,
} from "./markdown-code-machine"
import { renderMermaidSvg } from "./markdown-mermaid"
import { createMarkdownRenderer } from "./markdown-solid"
import {
@@ -208,18 +215,7 @@ function setCopyState(host: HTMLElement, labels: CopyLabels, copied: boolean) {
host.removeAttribute("data-copied")
}
// The Solid roots a code block holds besides its Copy button: plugin content and action buttons.
const codeHostDisposers = new WeakMap<HTMLElement, () => void>()
const codeHostSelector =
'[data-slot="markdown-copy-button"], [data-slot="markdown-code-actions"], [data-slot="markdown-code-content"]'
function disposeCodeHost(host: HTMLElement) {
copyButtonState.get(host)?.dispose()
copyButtonState.delete(host)
codeHostDisposers.get(host)?.()
codeHostDisposers.delete(host)
}
const codeHostSelector = '[data-slot="markdown-copy-button"], [data-component="markdown-code"]'
function disposeCodeHosts(root: Element) {
const hosts = [
@@ -227,7 +223,12 @@ function disposeCodeHosts(root: Element) {
...Array.from(root.querySelectorAll(codeHostSelector)).filter((el): el is HTMLElement => el instanceof HTMLElement),
]
hosts.forEach(disposeCodeHost)
hosts.forEach((host) => {
copyButtonState.get(host)?.dispose()
copyButtonState.delete(host)
codeDrivers.get(host)?.dispatch({ type: "disposed" })
codeDrivers.delete(host)
})
}
function disposeRenderedMarkdown(root: Element) {
@@ -263,114 +264,29 @@ function applyCodeMetadata(wrapper: HTMLElement, language: string | undefined) {
else delete wrapper.dataset.codeKind
}
function decorateMermaid(wrapper: HTMLElement, code: HTMLElement, complete: boolean) {
if (!code.classList.contains("language-mermaid")) {
clearMermaid(wrapper)
return
}
const source = code.textContent ?? ""
if (!source) return
const diagram = wrapper.querySelector('[data-component="markdown-mermaid"]') ?? document.createElement("div")
diagram.setAttribute("data-component", "markdown-mermaid")
if (!diagram.parentElement) wrapper.appendChild(diagram)
wrapper.dataset.mermaidPending = "true"
const input = complete ? source : source.slice(0, source.lastIndexOf("\n") + 1)
if (!input) return
const attempt = `${complete ? "complete" : "streaming"}:${input.length}`
if (wrapper.dataset.mermaidAttempt === attempt) return
wrapper.dataset.mermaidAttempt = attempt
void renderMermaidSvg(input)
.then((svg) => {
if (!svg) {
if (complete && code.textContent === source) clearMermaid(wrapper)
return
}
if (!(code.textContent ?? "").startsWith(input)) return
diagram.innerHTML = svg
delete wrapper.dataset.mermaidPending
wrapper.dataset.mermaidReady = "true"
})
.catch(() => {
if (!complete || code.textContent !== source) return
clearMermaid(wrapper)
})
}
function clearMermaid(wrapper: HTMLElement) {
delete wrapper.dataset.mermaidAttempt
delete wrapper.dataset.mermaidPending
delete wrapper.dataset.mermaidReady
wrapper.querySelector('[data-component="markdown-mermaid"]')?.remove()
}
type CodePlugins = { blocks: MarkdownCodeBlocks; match: MarkdownCodeBlockMatch }
type CodeMount = { match: MarkdownCodeBlockMatch; source: string; content?: HTMLElement }
// The plugins are the driver's input for mounting; the block's phase lives only in the machine's state.
type CodeDriver = { plugins: CodePlugins | undefined; dispatch: (event: CodeDecorationEvent) => void }
const codeMounts = new WeakMap<HTMLElement, CodeMount>()
const codeDrivers = new WeakMap<HTMLElement, CodeDriver>()
// Plugin content mounted into a block; `dispose` arrives once the plugin's render returns.
type CodeContent = { host: HTMLElement; dispose?: () => void }
// Content for a block's language replaces its code only once the closing fence arrived, so it never receives half a
// block; until then, and when the content declines or fails, the block shows its code (or the built-in diagram).
// Blocks of other languages take the plain path.
// Blocks of other languages take the plain path and never get a driver.
function decorateCode(wrapper: HTMLElement, code: HTMLElement, complete: boolean, plugins: CodePlugins | undefined) {
const previous = codeMounts.get(wrapper)
if (!plugins && !previous) return decorateMermaid(wrapper, code, complete)
const language = codeLanguage(wrapper.dataset.language)
const claimed = !!plugins?.match.render.has(language)
const acted = complete && !!plugins?.match.actions.has(language)
const existing = codeDrivers.get(wrapper)
if (!previous && !acted && !(claimed && complete))
return claimed ? clearMermaid(wrapper) : decorateMermaid(wrapper, code, complete)
if (!existing && !plugins && language !== "mermaid") return
const driver = existing ?? createCodeDriver(wrapper)
const source = (code.textContent ?? "").replace(/\n$/, "")
if (previous?.match === plugins?.match && previous?.source === source) return
if (previous) clearCodeMount(wrapper, previous)
if (!plugins || (!claimed && !acted)) return decorateMermaid(wrapper, code, complete)
if (!complete) return clearMermaid(wrapper)
const block = { code: source, language }
const mount: CodeMount = { match: plugins.match, source }
codeMounts.set(wrapper, mount)
if (acted)
wrapper.insertBefore(
createCodeActions(plugins.blocks, block),
wrapper.querySelector(':scope > [data-slot="markdown-copy-button"]'),
)
if (!claimed) return decorateMermaid(wrapper, code, complete)
clearMermaid(wrapper)
const content = document.createElement("div")
content.dataset.slot = "markdown-code-content"
mount.content = content
wrapper.dataset.codeContent = ""
wrapper.appendChild(content)
const dispose = plugins.blocks.render(content, block, () => {
if (mount.content === content) showCode(wrapper, code, mount)
})
// The content already failed while it rendered.
if (mount.content !== content) return dispose?.()
if (!dispose) return showCode(wrapper, code, mount)
codeHostDisposers.set(content, dispose)
if (!existing) codeDrivers.set(wrapper, driver)
driver.plugins = plugins
driver.dispatch({ type: "sync", language, source: code.textContent ?? "", complete, match: plugins?.match })
}
// Matches the language the worker's parser puts in a block's class, so streamed and completed blocks agree.
@@ -378,61 +294,126 @@ function codeLanguage(language: string | undefined) {
return (language ?? "").toLowerCase().replace(/[^\w#+.-]/g, "")
}
function showCode(wrapper: HTMLElement, code: HTMLElement, mount: CodeMount) {
const content = mount.content
mount.content = undefined
delete wrapper.dataset.codeContent
function createCodeDriver(wrapper: HTMLElement): CodeDriver {
let state = INITIAL_CODE_DECORATION_STATE
let actions: { host: HTMLElement; dispose: () => void } | undefined
let content: CodeContent | undefined
if (content) {
disposeCodeHost(content)
content.remove()
const dispatch = (event: CodeDecorationEvent) => {
const previous = state
const next = transitionCodeDecoration(state, event)
if (next.state === previous) return
state = next.state
showCodeDecoration(wrapper, viewCodeDecoration(previous), viewCodeDecoration(state))
next.effects.forEach(run)
}
decorateMermaid(wrapper, code, true)
const run = (effect: CodeDecorationEffect) => {
if (effect.type === "clear-actions") {
actions?.dispose()
actions?.host.remove()
actions = undefined
return
}
if (effect.type === "clear-plugin") {
content?.dispose?.()
content?.host.remove()
content = undefined
return
}
if (effect.type === "render-mermaid") {
void renderMermaidSvg(effect.input).then(
(svg) => dispatch({ type: "mermaid.resolved", attempt: effect.attempt, svg }),
() => dispatch({ type: "mermaid.failed", attempt: effect.attempt }),
)
return
}
const blocks = driver.plugins?.blocks
if (effect.type === "mount-actions") {
if (!blocks) return
actions = createCodeActions(blocks, effect.block)
wrapper.insertBefore(actions.host, wrapper.querySelector(':scope > [data-slot="markdown-copy-button"]'))
return
}
const host = document.createElement("div")
host.dataset.slot = "markdown-code-content"
wrapper.appendChild(host)
const mounted: CodeContent = { host }
content = mounted
const fallback = () => dispatch({ type: "plugin.failed", attempt: effect.attempt })
const dispose = blocks?.render(host, effect.block, fallback)
// The content already failed while it rendered.
if (content !== mounted) return dispose?.()
if (!dispose) return fallback()
mounted.dispose = dispose
}
const driver: CodeDriver = { plugins: undefined, dispatch }
return driver
}
function clearCodeMount(wrapper: HTMLElement, mount: CodeMount) {
codeMounts.delete(wrapper)
mount.content = undefined
delete wrapper.dataset.codeContent
wrapper
.querySelectorAll<HTMLElement>(
':scope > [data-slot="markdown-code-actions"], :scope > [data-slot="markdown-code-content"]',
)
.forEach((host) => {
disposeCodeHost(host)
host.remove()
})
function showCodeDecoration(
wrapper: HTMLElement,
previous: ReturnType<typeof viewCodeDecoration>,
view: ReturnType<typeof viewCodeDecoration>,
) {
if (view.pending) wrapper.dataset.mermaidPending = "true"
else delete wrapper.dataset.mermaidPending
if (view.svg !== undefined) wrapper.dataset.mermaidReady = "true"
else delete wrapper.dataset.mermaidReady
wrapper.toggleAttribute("data-code-content", view.content)
const existing = wrapper.querySelector(':scope > [data-component="markdown-mermaid"]')
if (!view.diagram) return existing?.remove()
const diagram = existing ?? document.createElement("div")
if (!existing) {
diagram.setAttribute("data-component", "markdown-mermaid")
wrapper.appendChild(diagram)
}
if (!existing || view.svg !== previous.svg) diagram.innerHTML = view.svg ?? ""
}
function createCodeActions(blocks: MarkdownCodeBlocks, block: MarkdownCodeBlock) {
const host = document.createElement("div")
host.setAttribute("data-slot", "markdown-code-actions")
codeHostDisposers.set(
host,
render(
() => (
<For each={blocks.actions(block.language)}>
{(action) => (
<Tooltip placement="top" value={action.title}>
<IconButton
type="button"
size="normal"
variant="ghost-muted"
aria-label={action.title}
icon={<Icon name={action.icon} />}
onClick={() => action.run(block)}
/>
</Tooltip>
)}
</For>
),
host,
const dispose = render(
() => (
<For each={blocks.actions(block.language)}>
{(action) => (
<Tooltip placement="top" value={action.title}>
<IconButton
type="button"
size="normal"
variant="ghost-muted"
aria-label={action.title}
icon={<Icon name={action.icon} />}
onClick={() => action.run(block)}
/>
</Tooltip>
)}
</For>
),
host,
)
return host
return { host, dispose }
}
function markCodeLinks(root: HTMLDivElement) {