Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
84 changes: 84 additions & 0 deletions src/app/components/DiagramColor.test.tsx
Original file line number Diff line number Diff line change
@@ -0,0 +1,84 @@
import { afterEach, expect, test } from 'bun:test'
import { RGBA } from '@opentui/core'
import { createTestRenderer } from '@opentui/core/testing'
import { createRoot } from '@opentui/react'
import { App } from '../App'
import { buildTreeFromTokens, lexMarkdown } from '../lib/ast'
import { renderDiagramBlocks } from '../lib/preprocess'
import { theme } from '../styles/theme'
import type { CliRenderer } from '@opentui/core'

const FIXTURE = ['# Diagram', '', '```mermaid', 'graph LR', ' A[Start] --> B[Done]', '```'].join(
'\n',
)

let active: CliRenderer | undefined

afterEach(() => {
active?.destroy()
active = undefined
})

async function setup() {
const { nodes, toc, headingIds } = buildTreeFromTokens(renderDiagramBlocks(lexMarkdown(FIXTURE)))
const { renderer, mockInput, flush, renderOnce, captureSpans } = await createTestRenderer({
width: 100,
height: 20,
})
active = renderer
const settle = async () => {
await flush({ maxPasses: 20 })
await new Promise(r => setTimeout(r, 30))
await renderOnce()
}
createRoot(renderer).render(
<App
nodes={nodes}
toc={toc}
headingIds={headingIds}
frontmatter={[]}
headingLines={{}}
fileLabel="t/diagram.md"
/>,
)
await settle()
// The very first key is consumed by the terminal capability handshake.
await mockInput.typeText('x')
await settle()
return { mockInput, settle, captureSpans }
}

/** Every rendered span containing `text`; the search bar also echoes the query. */
function spansWith(
captureSpans: Awaited<ReturnType<typeof createTestRenderer>>['captureSpans'],
text: string,
) {
return captureSpans().lines.flatMap(line => line.spans.filter(s => s.text.includes(text)))
}

const sameColor = (a: RGBA, hex: string) => {
const b = RGBA.fromHex(hex)
return [a.r - b.r, a.g - b.g, a.b - b.b].every(d => Math.abs(d) < 0.02)
}

test('each diagram node paints in its own palette hue', async () => {
const { captureSpans } = await setup()
expect(spansWith(captureSpans, 'Start').some(s => sameColor(s.fg, theme.diagramNodes[0]))).toBe(
true,
)
expect(spansWith(captureSpans, 'Done').some(s => sameColor(s.fg, theme.diagramNodes[1]))).toBe(
true,
)
})

test('a search match inside a colored diagram keeps the match background', async () => {
const { mockInput, settle, captureSpans } = await setup()
await mockInput.typeText('/')
await settle()
await mockInput.typeText('Done')
await settle()
mockInput.pressEnter()
await settle()
const done = spansWith(captureSpans, 'Done')
expect(done.some(s => s.text === 'Done' && sameColor(s.bg, theme.searchCurrentBg))).toBe(true)
})
34 changes: 24 additions & 10 deletions src/app/components/blocks/CodeBlock.tsx
Original file line number Diff line number Diff line change
@@ -1,11 +1,13 @@
import { RGBA, infoStringToFiletype } from '@opentui/core'
import type { TextChunk } from '@opentui/core'
import { useMemo } from 'react'
import { HighlightedText, RunScope, matchRangesForRun } from './InlineRenderer'
import { theme } from '../../styles/theme'
import { syntaxStyle } from '../../styles/syntax-style'
import { useAppState } from '../../state'
import { MERMAID_ASCII_LANG } from '../../lib/preprocess'
import { codeText, DIAGRAM_MARGIN_X, textWidth } from '../../lib/diagram-fit'
import { paintDiagram } from '../../lib/diagram-paint'
import type { Node } from '../../lib/ast'
import type { AppState } from '../../state'

Expand All @@ -22,16 +24,7 @@ export function CodeBlock({ node, id }: { node: Extract<Node, { kind: 'code' }>;
// reading column overflow it into the breakout columns; a `wrapMode="none"`
// text clips at its box edge otherwise.
if (node.lang === MERMAID_ASCII_LANG) {
const ascii = codeText({ node, breakoutWidth })
return (
<box id={id} marginX={DIAGRAM_MARGIN_X} minWidth={textWidth(ascii)}>
<text wrapMode="none">
<RunScope blockId={id} text={ascii}>
<HighlightedText value={ascii} />
</RunScope>
</text>
</box>
)
return <DiagramBlock ascii={codeText({ node, breakoutWidth })} id={id} />
}

const rawLang = node.lang && node.lang !== 'text' ? node.lang : undefined
Expand Down Expand Up @@ -77,6 +70,27 @@ export function CodeBlock({ node, id }: { node: Extract<Node, { kind: 'code' }>;
)
}

/**
* Runs concatenate back to `ascii`, so each `HighlightedText` piece advances the RunScope cursor
* in step with the projection and match spans paint over the run colors.
*/
function DiagramBlock({ ascii, id }: { ascii: string; id: string }) {
const runs = useMemo(() => paintDiagram(ascii), [ascii])
return (
<box id={id} marginX={DIAGRAM_MARGIN_X} minWidth={textWidth(ascii)}>
<text wrapMode="none">
<RunScope blockId={id} text={ascii}>
{runs.map((run, i) => (
<span key={i} fg={run.fg}>
<HighlightedText value={run.text} />
</span>
))}
</RunScope>
</text>
</box>
)
}

const MATCH_BG = RGBA.fromHex(theme.searchMatchBg)
const MATCH_CURRENT_BG = RGBA.fromHex(theme.searchCurrentBg)
const MATCH_FG = RGBA.fromHex(theme.searchMatchFg)
Expand Down
92 changes: 92 additions & 0 deletions src/app/lib/diagram-paint.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,92 @@
import { describe, expect, test } from 'bun:test'
import { paintDiagram } from './diagram-paint'
import { renderAscii } from './preprocess'
import { theme } from '../styles/theme'
import type { DiagramRun } from './diagram-paint'

const render = (source: string): string => {
const ascii = renderAscii(source)
if (ascii === undefined) throw new Error(`diagram failed to render: ${source}`)
return ascii
}

const FLOW = render('graph LR\n A[Start] --> B{Ok?}\n B -->|yes| C(Done)\n B -->|no| A')
const SUBGRAPH = render('graph TD\n subgraph S [Group]\n X --> Y\n end\n Y --> Z')
const SEQUENCE = render('sequenceDiagram\n Alice->>Bob: Hi\n Bob-->>Alice: Yo')

const [FIRST, SECOND, THIRD] = theme.diagramNodes

/** Per-cell fg, rebuilt from the runs so tests assert on what each glyph paints as. */
const colorGrid = (runs: DiagramRun[]): (string | undefined)[][] => {
const grid: (string | undefined)[][] = [[]]
for (const run of runs) {
for (const ch of Array.from(run.text)) {
if (ch === '\n') grid.push([])
else grid[grid.length - 1]?.push(run.fg)
}
}
return grid
}

/** Color of the nth occurrence of `needle` in the diagram text. */
const colorOf = (text: string, needle: string, nth = 0): string | undefined => {
const lines = text.split('\n')
let seen = 0
for (let r = 0; r < lines.length; r++) {
const chars = Array.from(lines[r] ?? '')
for (let c = 0; c < chars.length; c++) {
if (!chars.slice(c).join('').startsWith(needle)) continue
if (seen++ === nth) return colorGrid(paintDiagram(text))[r]?.[c]
}
}
throw new Error(`"${needle}" #${nth} not found`)
}

describe('paintDiagram', () => {
test('run texts concatenate back to the input exactly', () => {
for (const text of [FLOW, SUBGRAPH, SEQUENCE]) {
expect(
paintDiagram(text)
.map(r => r.text)
.join(''),
).toBe(text)
}
})

test('a node box and its label share one palette hue', () => {
expect(colorOf(FLOW, 'Start')).toBe(FIRST)
expect(colorOf(FLOW, '┌')).toBe(FIRST)
expect(colorOf(FLOW, '┘')).toBe(FIRST)
})

test('distinct labels take successive palette hues', () => {
expect(colorOf(FLOW, 'Ok?')).toBe(SECOND)
expect(colorOf(FLOW, 'Done')).toBe(THIRD)
})

test('a repeated label reuses its hue', () => {
expect(colorOf(SEQUENCE, 'Alice', 0)).toBe(FIRST)
expect(colorOf(SEQUENCE, 'Alice', 1)).toBe(FIRST)
expect(colorOf(SEQUENCE, 'Bob', 1)).toBe(SECOND)
})

test('the palette wraps once every hue is taken', () => {
const ids = 'ABCDEFG'.split('')
const chain = render(`graph LR\n ${ids.map(id => `${id}[N${id}]`).join(' --> ')}`)
expect(colorOf(chain, `N${ids[theme.diagramNodes.length]}`)).toBe(FIRST)
})

test('a subgraph frame paints as a line and its title as text', () => {
expect(colorOf(SUBGRAPH, '┌───────┐')).toBe(theme.diagramLine)
expect(colorOf(SUBGRAPH, 'Group')).toBe(theme.diagramText)
expect(colorOf(SUBGRAPH, 'X')).toBe(FIRST)
})

test('edges paint lines, arrowheads, and edge labels by role', () => {
expect(colorOf(FLOW, '─yes')).toBe(theme.diagramLine)
expect(colorOf(FLOW, '►')).toBe(theme.diagramArrow)
expect(colorOf(FLOW, 'yes')).toBe(theme.diagramText)
expect(colorOf(SEQUENCE, '▶')).toBe(theme.diagramArrow)
expect(colorOf(SEQUENCE, '◀')).toBe(theme.diagramArrow)
})
})
104 changes: 104 additions & 0 deletions src/app/lib/diagram-paint.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,104 @@
import { theme } from '../styles/theme'

/** A stretch of diagram text in one color; a diagram's runs concatenate back to its text. */
export type DiagramRun = { text: string; fg: string }

type Box = { top: number; left: number; bottom: number; right: number }

const TOP_LEFT = /[┌╭]/
const TOP_RIGHT = /[┐╮]/
const BOTTOM_LEFT = /[└╰]/
const BOTTOM_RIGHT = /[┘╯]/
// Edges join box borders, so a border admits tees, crosses, and arrowheads.
const TOP_BORDER = /[─┬┴┼▲▼]/
const LEFT_BORDER = /[│├┤┼►◄▶◀]/
const ARROW = /[►◄▲▼▶◀]/
const BOX_DRAWING = /[─-╿]/

/**
* Colors rendered diagram text. Each innermost box (border and label) takes the next node hue,
* keyed by label so a repeated node keeps its hue. Every other glyph is colored by role, so
* enclosing boxes such as subgraph frames paint as lines.
*/
export function paintDiagram(text: string): DiagramRun[] {
const grid = text.split('\n').map(line => Array.from(line))
const boxColors = paintBoxes(grid)
return grid.reduce<DiagramRun[]>((runs, row, r) => {
if (r > 0) appendCell(runs, '\n', undefined)
row.forEach((ch, c) => appendCell(runs, ch, boxColors[r]?.[c] ?? roleColor(ch)))
return runs
}, [])
}

/** Uncolored cells (whitespace, newlines) join the current run so runs stay few. */
function appendCell(runs: DiagramRun[], ch: string, fg: string | undefined): DiagramRun[] {
const last = runs.at(-1)
if (last && (fg === undefined || fg === last.fg)) last.text += ch
else runs.push({ text: ch, fg: fg ?? theme.diagramText })
return runs
}

function roleColor(ch: string): string | undefined {
if (!ch.trim()) return undefined
if (ARROW.test(ch)) return theme.diagramArrow
if (BOX_DRAWING.test(ch)) return theme.diagramLine
return theme.diagramText
}

function paintBoxes(grid: string[][]): (string | undefined)[][] {
const colors = grid.map(row => row.map((): string | undefined => undefined))
const boxes = findBoxes(grid)
const hues = new Map<string, string>()
for (const box of boxes.filter(outer => !boxes.some(inner => encloses(outer, inner)))) {
const label = boxLabel(grid, box)
const hue = hues.get(label) ?? nodeHue(hues.size)
hues.set(label, hue)
for (let r = box.top; r <= box.bottom; r++) {
const row = colors[r]
if (!row) continue
for (let c = box.left; c <= box.right; c++) if (grid[r]?.[c]?.trim()) row[c] = hue
}
}
return colors
}

function findBoxes(grid: string[][]): Box[] {
const at = (r: number, c: number) => grid[r]?.[c] ?? ''
const boxes: Box[] = []
grid.forEach((row, top) =>
row.forEach((ch, left) => {
if (!TOP_LEFT.test(ch)) return
let right = left + 1
while (TOP_BORDER.test(at(top, right))) right++
if (right === left + 1 || !TOP_RIGHT.test(at(top, right))) return
let bottom = top + 1
while (LEFT_BORDER.test(at(bottom, left))) bottom++
if (!BOTTOM_LEFT.test(at(bottom, left)) || !BOTTOM_RIGHT.test(at(bottom, right))) return
boxes.push({ top, left, bottom, right })
}),
)
return boxes
}

function encloses(outer: Box, inner: Box): boolean {
return (
inner !== outer &&
inner.top > outer.top &&
inner.bottom < outer.bottom &&
inner.left > outer.left &&
inner.right < outer.right
)
}

function boxLabel(grid: string[][], box: Box): string {
return grid
.slice(box.top + 1, box.bottom)
.map(row => row.slice(box.left + 1, box.right).join(''))
.join(' ')
.replace(/\s+/g, ' ')
.trim()
}

function nodeHue(index: number): string {
return theme.diagramNodes[index % theme.diagramNodes.length] ?? theme.diagramText
}
6 changes: 6 additions & 0 deletions src/app/styles/theme.ts
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,12 @@ export const theme = {
scrollMarkActive: '#f59e1f', // brightest — reuse searchCurrentBg
scrollbarThumb: '#585858', // thumb color; marker cells inside the thumb use it as bg
scrollbarTrack: '#252527', // track bg (OpenTUI default, pinned); marker cells outside the thumb use it as bg
// Node hues, assigned in order: cyan, green, magenta, codespanFg, blue. Yellow would read as a
// search match (searchMatchBg) and red as an error, so neither is a node hue.
diagramNodes: ['#11a8cd', '#23d18b', '#bc3fbc', '#ce9178', '#2472c8'],
diagramLine: '#666666', // matches border; edges recede so nodes carry the color
diagramArrow: '#9d9d9d', // matches foregroundMuted; brighter than lines so direction reads
diagramText: '#d4d4d4', // matches foreground
} as const

export type Theme = typeof theme
13 changes: 13 additions & 0 deletions test/mermaid.md
Original file line number Diff line number Diff line change
Expand Up @@ -126,6 +126,9 @@ stateDiagram-v2

### Notes

`beautiful-mermaid` parses notes only in sequence diagrams; it drops this
state note silently, so only `[*] --> A` renders.

```mermaid
stateDiagram-v2
[*] --> A
Expand Down Expand Up @@ -205,6 +208,16 @@ sequenceDiagram
Note right of B: processing
```

### Notes: left, over one, over a span

```mermaid
sequenceDiagram
A->>B: hi
Note left of A: before
Note over B: waiting
Note over A,B: shared
```

## Class Diagrams

### Attributes and methods
Expand Down
Loading