179 lines
7.5 KiB
TypeScript
179 lines
7.5 KiB
TypeScript
import { logForDebugging } from 'src/utils/debug.js'
|
||
import { type DOMElement, markDirty } from './dom.js'
|
||
import type { Frame } from './frame.js'
|
||
import { consumeAbsoluteRemovedFlag } from './node-cache.js'
|
||
import Output from './output.js'
|
||
import renderNodeToOutput, {
|
||
getScrollDrainNode,
|
||
getScrollHint,
|
||
resetLayoutShifted,
|
||
resetScrollDrainNode,
|
||
resetScrollHint,
|
||
} from './render-node-to-output.js'
|
||
import { createScreen, type StylePool } from './screen.js'
|
||
|
||
export type RenderOptions = {
|
||
frontFrame: Frame
|
||
backFrame: Frame
|
||
isTTY: boolean
|
||
terminalWidth: number
|
||
terminalRows: number
|
||
altScreen: boolean
|
||
// True when the previous frame's screen buffer was mutated post-render
|
||
// (selection overlay), reset to blank (alt-screen enter/resize/SIGCONT),
|
||
// or reset to 0×0 (forceRedraw). Blitting from such a prevScreen would
|
||
// copy stale inverted cells, blanks, or nothing. When false, blit is safe.
|
||
prevFrameContaminated: boolean
|
||
}
|
||
|
||
export type Renderer = (options: RenderOptions) => Frame
|
||
|
||
export default function createRenderer(
|
||
node: DOMElement,
|
||
stylePool: StylePool,
|
||
): Renderer {
|
||
// Reuse Output across frames so charCache (tokenize + grapheme clustering)
|
||
// persists — most lines don't change between renders.
|
||
let output: Output | undefined
|
||
return options => {
|
||
const { frontFrame, backFrame, isTTY, terminalWidth, terminalRows } =
|
||
options
|
||
const prevScreen = frontFrame.screen
|
||
const backScreen = backFrame.screen
|
||
// Read pools from the back buffer's screen — pools may be replaced
|
||
// between frames (generational reset), so we can't capture them in the closure
|
||
const charPool = backScreen.charPool
|
||
const hyperlinkPool = backScreen.hyperlinkPool
|
||
|
||
// Return empty frame if yoga node doesn't exist or layout hasn't been computed yet.
|
||
// getComputedHeight() returns NaN before calculateLayout() is called.
|
||
// Also check for invalid dimensions (negative, Infinity) that would cause RangeError
|
||
// when creating arrays.
|
||
const computedHeight = node.yogaNode?.getComputedHeight()
|
||
const computedWidth = node.yogaNode?.getComputedWidth()
|
||
const hasInvalidHeight =
|
||
computedHeight === undefined ||
|
||
!Number.isFinite(computedHeight) ||
|
||
computedHeight < 0
|
||
const hasInvalidWidth =
|
||
computedWidth === undefined ||
|
||
!Number.isFinite(computedWidth) ||
|
||
computedWidth < 0
|
||
|
||
if (!node.yogaNode || hasInvalidHeight || hasInvalidWidth) {
|
||
// Log to help diagnose root cause (visible with --debug flag)
|
||
if (node.yogaNode && (hasInvalidHeight || hasInvalidWidth)) {
|
||
logForDebugging(
|
||
`Invalid yoga dimensions: width=${computedWidth}, height=${computedHeight}, ` +
|
||
`childNodes=${node.childNodes.length}, terminalWidth=${terminalWidth}, terminalRows=${terminalRows}`,
|
||
)
|
||
}
|
||
return {
|
||
screen: createScreen(
|
||
terminalWidth,
|
||
0,
|
||
stylePool,
|
||
charPool,
|
||
hyperlinkPool,
|
||
),
|
||
viewport: { width: terminalWidth, height: terminalRows },
|
||
cursor: { x: 0, y: 0, visible: true },
|
||
}
|
||
}
|
||
|
||
const width = Math.floor(node.yogaNode.getComputedWidth())
|
||
const yogaHeight = Math.floor(node.yogaNode.getComputedHeight())
|
||
// Alt-screen: the screen buffer IS the alt buffer — always exactly
|
||
// terminalRows tall. <AlternateScreen> wraps children in <Box
|
||
// height={rows} flexShrink={0}>, so yogaHeight should equal
|
||
// terminalRows. But if something renders as a SIBLING of that Box
|
||
// (bug: MessageSelector was outside <FullscreenLayout>), yogaHeight
|
||
// exceeds rows and every assumption below (viewport +1 hack, cursor.y
|
||
// clamp, log-update's heightDelta===0 fast path) breaks, desyncing
|
||
// virtual/physical cursors. Clamping here enforces the invariant:
|
||
// overflow writes land at y >= screen.height and setCellAt drops
|
||
// them. The sibling is invisible (obvious, easy to find) instead of
|
||
// corrupting the whole terminal.
|
||
const height = options.altScreen ? terminalRows : yogaHeight
|
||
if (options.altScreen && yogaHeight > terminalRows) {
|
||
logForDebugging(
|
||
`alt-screen: yoga height ${yogaHeight} > terminalRows ${terminalRows} — ` +
|
||
`something is rendering outside <AlternateScreen>. Overflow clipped.`,
|
||
{ level: 'warn' },
|
||
)
|
||
}
|
||
const screen =
|
||
backScreen ??
|
||
createScreen(width, height, stylePool, charPool, hyperlinkPool)
|
||
if (output) {
|
||
output.reset(width, height, screen)
|
||
} else {
|
||
output = new Output({ width, height, stylePool, screen })
|
||
}
|
||
|
||
resetLayoutShifted()
|
||
resetScrollHint()
|
||
resetScrollDrainNode()
|
||
|
||
// prevFrameContaminated: selection overlay mutated the returned screen
|
||
// buffer post-render (in ink.tsx), resetFramesForAltScreen() replaced it
|
||
// with blanks, or forceRedraw() reset it to 0×0. Blit on the NEXT frame
|
||
// would copy stale inverted cells / blanks / nothing. When clean, blit
|
||
// restores the O(unchanged) fast path for steady-state frames (spinner
|
||
// tick, text stream).
|
||
// Removing an absolute-positioned node poisons prevScreen: it may
|
||
// have painted over non-siblings (e.g. an overlay over a ScrollBox
|
||
// earlier in tree order), so their blits would restore the removed
|
||
// node's pixels. hasRemovedChild only shields direct siblings.
|
||
// Normal-flow removals don't paint cross-subtree and are fine.
|
||
const absoluteRemoved = consumeAbsoluteRemovedFlag()
|
||
renderNodeToOutput(node, output, {
|
||
prevScreen:
|
||
absoluteRemoved || options.prevFrameContaminated
|
||
? undefined
|
||
: prevScreen,
|
||
})
|
||
|
||
const renderedScreen = output.get()
|
||
|
||
// Drain continuation: render cleared scrollbox.dirty, so next frame's
|
||
// root blit would skip the subtree. markDirty walks ancestors so the
|
||
// next frame descends. Done AFTER render so the clear-dirty at the end
|
||
// of renderNodeToOutput doesn't overwrite this.
|
||
const drainNode = getScrollDrainNode()
|
||
if (drainNode) markDirty(drainNode)
|
||
|
||
return {
|
||
scrollHint: options.altScreen ? getScrollHint() : null,
|
||
scrollDrainPending: drainNode !== null,
|
||
screen: renderedScreen,
|
||
viewport: {
|
||
width: terminalWidth,
|
||
// Alt screen: fake viewport.height = rows + 1 so that
|
||
// shouldClearScreen()'s `screen.height >= viewport.height` check
|
||
// (which treats exactly-filling content as "overflows" for
|
||
// scrollback purposes) never fires. Alt-screen content is always
|
||
// exactly `rows` tall (via <Box height={rows}>) but never
|
||
// scrolls — the cursor.y clamp below keeps the cursor-restore
|
||
// from emitting an LF. With the standard diff path, every frame
|
||
// is incremental; no fullResetSequence_CAUSES_FLICKER.
|
||
height: options.altScreen ? terminalRows + 1 : terminalRows,
|
||
},
|
||
cursor: {
|
||
x: 0,
|
||
// In the alt screen, keep the cursor inside the viewport. When
|
||
// screen.height === terminalRows exactly (content fills the alt
|
||
// screen), cursor.y = screen.height would trigger log-update's
|
||
// cursor-restore LF at the last row, scrolling one row off the top
|
||
// of the alt buffer and desyncing the diff's cursor model. The
|
||
// cursor is hidden so its position only matters for diff coords.
|
||
y: options.altScreen
|
||
? Math.max(0, Math.min(screen.height, terminalRows) - 1)
|
||
: screen.height,
|
||
// Hide cursor when there's dynamic output to render (only in TTY mode)
|
||
visible: !isTTY || screen.height === 0,
|
||
},
|
||
}
|
||
}
|
||
}
|