fix(session-ui): drive the Pierre viewer render lifecycle with one state machine (#61938)

This commit is contained in:
Luke Parker
2026-11-04 23:08:03 -06:00
committed by GitHub
Unverified
parent 2b9216a002
commit c293e53511
6 changed files with 1114 additions and 458 deletions
@@ -47,6 +47,11 @@ export const controls = {
keepHost: () => (first = document.querySelector("[data-testid='file-viewer-fixture'] diffs-container")),
sameHost: () =>
first !== null && first === document.querySelector("[data-testid='file-viewer-fixture'] diffs-container"),
clearDiff: () => {},
/** The inline min-height the viewer pins on its container while a draw replaces rows. */
pinnedHeight: () =>
document.querySelector<HTMLElement>("[data-testid='file-viewer-fixture'] div:has(> diffs-container)")?.style
.minHeight,
}
function host() {
@@ -77,6 +82,24 @@ export function mountTextViewer(lines: number) {
)
}
/** A plain diff of `lines` lines; `controls.clearDiff()` then makes both sides identical, which draws no rows. */
export function mountChangingDiff(lines: number) {
const [after, setAfter] = createSignal(source(lines, 1))
controls.clearDiff = () => setAfter(source(lines))
render(
() => (
<File
mode="diff"
fileDiff={
normalize({ file: "a.ts", before: source(lines), after: after(), additions: 0, deletions: 0 }).fileDiff
}
diffStyle="unified"
/>
),
host(),
)
}
export function mountDiffViewer(lines: number) {
const view = normalize({ file: "a.ts", before: source(lines), after: source(lines, 1), additions: 0, deletions: 0 })
render(
@@ -119,6 +119,19 @@ story("does not end a drag that a fast second press replaced", async ({ mount, p
await expect.poll(ends).toEqual([{ start: 10, end: 12 }])
})
story("releases the pinned height when a diff becomes empty", async ({ mount, page }) => {
await mount("components-markdown--compact-result")
await page.evaluate(async (fixture) => (await import(fixture)).mountChangingDiff(40), fixture)
const root = page.getByTestId("file-viewer-fixture")
await expect(root.locator('[data-line-type="change-addition"]').first()).toBeVisible()
const pinned = () => page.evaluate(async (fixture) => (await import(fixture)).controls.pinnedHeight(), fixture)
await expect.poll(pinned).toBe("")
await page.evaluate(async (fixture) => (await import(fixture)).controls.clearDiff(), fixture)
await expect(root.locator('[data-line-type="change-addition"]')).toHaveCount(0)
await expect.poll(pinned).toBe("")
})
story("scrolls a virtualized diff to an off-screen selection", async ({ mount, page }) => {
await mount("components-markdown--compact-result")
await page.evaluate(async (fixture) => (await import(fixture)).mountDiffViewer(480), fixture)
+405 -371
View File
@@ -1,6 +1,5 @@
import { sampledChecksum } from "@opencode/util/encode"
import {
areFilesEqual,
areOptionsEqual,
DEFAULT_VIRTUAL_FILE_METRICS,
type DiffLineAnnotation,
@@ -36,15 +35,7 @@ import { createDefaultOptions, styleVariables } from "../pierre"
import { markCommentedDiffLines, markCommentedFileLines } from "../pierre/commented-lines"
import { fixDiffSelection, findDiffSide, type DiffSelectionSide } from "../pierre/diff-selection"
import { createFileFind } from "../pierre/file-find"
import {
applyViewerScheme,
clearReadyWatcher,
createReadyWatcher,
getViewerHost,
getViewerRoot,
notifyShadowReady,
observeViewerScheme,
} from "../pierre/file-runtime"
import { applyViewerScheme, getViewerHost, getViewerRoot, observeViewerScheme } from "../pierre/file-runtime"
import {
findCodeSelectionSide,
findDiffLineNumber,
@@ -52,6 +43,21 @@ import {
findFileLineNumber,
readShadowLineSelection,
} from "../pierre/file-selection"
import {
diffExpectsRows,
INITIAL_VIEWER_RENDER_STATE,
POOL_INIT_TIMEOUT_MS,
readPoolState,
ROWS_READY_TIMEOUT_MS,
selectMountedSpec,
selectRevision,
transitionViewerRender,
type ViewerInstanceSpec,
type ViewerRenderEffect,
type ViewerRenderEvent,
type ViewerRenderRequest,
type ViewerTarget,
} from "../pierre/render-machine"
import { restoreShadowTextSelection } from "../pierre/selection-bridge"
import {
createFileSelectionState,
@@ -168,7 +174,6 @@ type ViewerConfig = {
mode: FileSelectionMode
enableLineSelection: () => boolean
selectedLines: () => SelectedLineRange | null | undefined
commentedLines: () => SelectedLineRange[]
callbacks: SelectionCallbacks
// mode-specific callbacks
@@ -180,7 +185,6 @@ type ViewerConfig = {
applySelection: (range: SelectedLineRange | null) => void
/** Adjusts a range Pierre reports before the machine stores it. */
normalize?: (range: SelectedLineRange | null) => SelectedLineRange | null | undefined
markCommented: (root: ShadowRoot, ranges: SelectedLineRange[]) => void
}
type PointerMove = {
@@ -207,9 +211,6 @@ function useFileViewer(config: ViewerConfig) {
const hit: MouseHit = { line: undefined, numberColumn: false, side: undefined }
const moveEvent: PointerMove = { type: "pointer.move", buttons: 0, line: undefined, side: undefined }
const ready = createReadyWatcher()
const [rendered, setRendered] = createSignal(0)
const getRoot = () => getViewerRoot(container)
const getHost = () => getViewerHost(container)
@@ -366,41 +367,6 @@ function useFileViewer(config: ViewerConfig) {
onCleanup(observeViewerScheme(getHost))
})
createEffect(() => {
rendered()
const ranges = config.commentedLines()
const root = getRoot()
if (!root) return
if (ranges.length === 0) {
config.markCommented(root, ranges)
return
}
let frame: number | undefined
const mark = () => {
if (frame !== undefined) cancelAnimationFrame(frame)
frame = requestAnimationFrame(() => {
frame = undefined
config.markCommented(root, ranges)
})
}
const observer = new MutationObserver(mark)
observer.observe(root, { childList: true, subtree: true })
mark()
onCleanup(() => {
observer.disconnect()
if (frame !== undefined) cancelAnimationFrame(frame)
})
})
createEffect(() => {
const range = config.selectedLines() ?? null
untrack(() => dispatch({ type: "selection.controlled", range }))
@@ -419,10 +385,7 @@ function useFileViewer(config: ViewerConfig) {
makeEventListener(document, "selectionchange", handleSelectionChange)
})
onCleanup(() => {
clearReadyWatcher(ready)
dispatch({ type: "disposed" })
})
onCleanup(() => dispatch({ type: "disposed" }))
return {
get wrapper() {
@@ -443,9 +406,6 @@ function useFileViewer(config: ViewerConfig) {
set overlay(v: HTMLDivElement) {
overlay = v
},
ready,
rendered,
setRendered,
getRoot,
getHost,
find,
@@ -467,11 +427,6 @@ type RenderTarget = {
cleanUp: () => void
}
type AnnotationTarget<A> = {
setLineAnnotations: (annotations: A[]) => void
rerender: () => void
}
type VirtualStrategy = {
get: () => Virtualizer | undefined
cleanup: () => void
@@ -495,75 +450,256 @@ function useSearchHandle(opts: {
})
}
function useAnnotationRerender<A>(opts: {
viewer: Viewer
current: () => AnnotationTarget<A> | undefined
annotations: () => A[]
}) {
const applied = new WeakSet<AnnotationTarget<A>>()
createEffect(() => {
opts.viewer.rendered()
const active = opts.current()
if (!active) return
const annotations = opts.annotations()
// renderViewer always draws with empty annotations, so skip the extra rerender
// when this instance has nothing applied and nothing to apply.
if (annotations.length === 0 && !applied.has(active)) return
if (annotations.length === 0) applied.delete(active)
else applied.add(active)
active.setLineAnnotations(annotations)
active.rerender()
requestAnimationFrame(() => opts.viewer.find.refresh({ reset: true }))
})
}
function notifyRendered(opts: {
type ViewerRenderConfig<I extends RenderTarget, O> = {
viewer: Viewer
/** Pierre options; a change redraws, and a draw always uses the latest ones. */
options: () => O
/** Reads every other input a draw depends on; a change requests a new draw. */
request: () => ViewerRenderRequest
create: (spec: ViewerInstanceSpec, options: O) => I
/** Applies options to a kept instance and returns whether its rows must render again. */
update: (instance: I, options: O) => boolean
draw: (instance: I, spec: ViewerInstanceSpec, forceRender: boolean) => void
isReady: (root: ShadowRoot) => boolean
settleFrames?: number
onReady: () => void
}) {
notifyShadowReady({
state: opts.viewer.ready,
container: opts.viewer.container,
getRoot: opts.viewer.getRoot,
isReady: opts.isReady,
settleFrames: opts.settleFrames,
onReady: opts.onReady,
})
annotations: () => unknown[]
applyAnnotations: (instance: I) => void
commentedLines: () => SelectedLineRange[]
markCommented: (root: ShadowRoot, ranges: SelectedLineRange[]) => void
/** Scrolls a range into a virtualized window; returns false while rows cannot be measured yet. */
reveal?: (instance: I, spec: ViewerInstanceSpec, range: SelectedLineRange) => boolean
onRendered: () => void
}
function renderViewer<I extends RenderTarget>(opts: {
viewer: Viewer
current: I | undefined
reset?: boolean
create: () => I
update?: (value: I) => void
assign: (value: I) => void
draw: (value: I) => void
onReady: () => void
}) {
clearReadyWatcher(opts.viewer.ready)
const reset = opts.reset === true && opts.current !== undefined
type ViewerRender<I> = {
instance: () => I | undefined
requestReveal: (range: SelectedLineRange | undefined) => void
}
if (reset) opts.current?.cleanUp()
const next = reset || !opts.current ? opts.create() : opts.current
function useViewerRender<I extends RenderTarget, O>(config: ViewerRenderConfig<I, O>): ViewerRender<I> {
const viewer = config.viewer
let state = INITIAL_VIEWER_RENDER_STATE
let instance: I | undefined
let observer: MutationObserver | undefined
let poolTimer: ReturnType<typeof setTimeout> | undefined
let rowsTimer: ReturnType<typeof setTimeout> | undefined
let settleFrame: number | undefined
let findFrame: number | undefined
let releaseHeight: VoidFunction | undefined
const [revision, setRevision] = createSignal(selectRevision(state))
if (reset || !opts.current) {
opts.viewer.container.innerHTML = ""
opts.assign(next)
} else {
opts.update?.(next)
const cancelAsync = () => {
observer?.disconnect()
observer = undefined
clearTimeout(poolTimer)
clearTimeout(rowsTimer)
poolTimer = undefined
rowsTimer = undefined
if (settleFrame !== undefined) cancelAnimationFrame(settleFrame)
settleFrame = undefined
}
opts.draw(next)
const watchRows = (attempt: number) => {
const done = () => {
observer?.disconnect()
observer = undefined
clearTimeout(rowsTimer)
rowsTimer = undefined
dispatch({ type: "rows.ready", attempt })
}
applyViewerScheme(opts.viewer.getHost())
opts.viewer.setRendered((value) => value + 1)
opts.onReady()
const watchRoot = (root: ShadowRoot) => {
observer?.disconnect()
observer = new MutationObserver(() => {
if (config.isReady(root)) done()
})
observer.observe(root, { childList: true, subtree: true })
}
const root = viewer.getRoot()
if (root && config.isReady(root)) return done()
rowsTimer = setTimeout(() => {
rowsTimer = undefined
dispatch({ type: "rows.timed-out", attempt })
}, ROWS_READY_TIMEOUT_MS)
if (root) return watchRoot(root)
observer = new MutationObserver(() => {
const next = viewer.getRoot()
if (!next) return
if (config.isReady(next)) return done()
watchRoot(next)
})
observer.observe(viewer.container, { childList: true, subtree: true })
}
const run = (effect: ViewerRenderEffect) => {
if (effect.type === "cancel-async") return cancelAsync()
if (effect.type === "await-pool") {
poolTimer = setTimeout(() => {
poolTimer = undefined
dispatch({ type: "pool.timed-out", attempt: effect.attempt })
}, POOL_INIT_TIMEOUT_MS)
void effect.pool.initialize().then(
() => dispatch({ type: "pool.settled", attempt: effect.attempt, ok: true }),
() => dispatch({ type: "pool.settled", attempt: effect.attempt, ok: false }),
)
return
}
if (effect.type === "preserve-height") {
releaseHeight ??= preserve(viewer)
return
}
if (effect.type === "release-height") {
releaseHeight?.()
releaseHeight = undefined
return
}
if (effect.type === "draw") {
if (effect.action === "reset") {
instance?.cleanUp()
instance = undefined
}
const options = config.options()
const forceRender = instance ? config.update(instance, options) : false
if (!instance) {
viewer.container.innerHTML = ""
instance = config.create(effect.spec, options)
}
config.draw(instance, effect.spec, forceRender)
applyViewerScheme(viewer.getHost())
return
}
if (effect.type === "sync-annotations")
return dispatch({ type: "annotations.synced", count: config.annotations().length })
if (effect.type === "apply-annotations") {
if (!instance) return
config.applyAnnotations(instance)
if (findFrame !== undefined) cancelAnimationFrame(findFrame)
findFrame = requestAnimationFrame(() => {
findFrame = undefined
viewer.find.refresh({ reset: true })
})
return
}
if (effect.type === "watch-rows") return watchRows(effect.attempt)
if (effect.type === "schedule-settle-frame") {
settleFrame = requestAnimationFrame(() => {
settleFrame = undefined
dispatch({ type: "settle.frame", attempt: effect.attempt })
})
return
}
if (effect.type === "reapply-selection") return viewer.reapplySelection()
if (effect.type === "try-reveal") {
const spec = selectMountedSpec(state)
if (!instance || !spec) return
if (!config.reveal || config.reveal(instance, spec, effect.range)) dispatch({ type: "reveal.completed" })
return
}
if (effect.type === "refresh-find") return viewer.find.refresh({ reset: true })
if (effect.type === "notify-rendered") return config.onRendered()
instance?.cleanUp()
instance = undefined
if (findFrame !== undefined) cancelAnimationFrame(findFrame)
}
// Effects can dispatch again synchronously (rows already drawn, annotations synced after a draw).
const dispatch = (event: ViewerRenderEvent) => {
const step = transitionViewerRender(state, event)
const changed = selectRevision(step.state) !== selectRevision(state)
state = step.state
step.effects.forEach(run)
if (changed && state.status !== "disposed") setRevision(selectRevision(state))
}
createEffect(() => {
config.options()
const request = config.request()
untrack(() => dispatch({ type: "render.requested", request }))
})
// Each draw syncs annotations itself, so only later changes dispatch here.
createEffect(
on(config.annotations, (annotations) => dispatch({ type: "annotations.synced", count: annotations.length }), {
defer: true,
}),
)
createEffect(() => {
revision()
const ranges = config.commentedLines()
const root = viewer.getRoot()
if (!root) return
if (ranges.length === 0) {
config.markCommented(root, ranges)
return
}
let frame: number | undefined
const mark = () => {
if (frame !== undefined) cancelAnimationFrame(frame)
frame = requestAnimationFrame(() => {
frame = undefined
config.markCommented(root, ranges)
})
}
const watch = new MutationObserver(mark)
watch.observe(root, { childList: true, subtree: true })
mark()
onCleanup(() => {
watch.disconnect()
if (frame !== undefined) cancelAnimationFrame(frame)
})
})
onCleanup(() => dispatch({ type: "disposed" }))
return {
instance: () => instance,
requestReveal: (range) => dispatch({ type: "reveal.requested", range }),
}
}
function preserve(viewer: Viewer) {
@@ -676,22 +812,6 @@ function createSharedVirtualStrategy(host: () => HTMLDivElement | undefined, ena
}
}
// Pierre draws nothing until its worker pool initializes, and a virtualizer that first sees an empty file at the top
// of its scroller anchors the file's bottom edge, then scrolls to the end once the rows arrive.
function createPoolReady() {
const [settled, setSettled] = createSignal(false)
return (pool: ReturnType<typeof getWorkerPool>) => {
if (!pool || pool.isInitialized() || settled()) return true
void pool
.initialize()
.catch(() => undefined)
.then(() => setSettled(true))
return false
}
}
function parseLine(node: HTMLElement) {
if (!node.dataset.line) return
const value = parseInt(node.dataset.line, 10)
@@ -805,9 +925,8 @@ function ViewerShell(props: {
// ---------------------------------------------------------------------------
function TextViewer<T>(props: TextFileProps<T>) {
let instance: PierreFile<T> | VirtualizedFile<T> | undefined
let instanceVirtualizer: Virtualizer | undefined
let viewer!: Viewer
let render!: ViewerRender<PierreFile<T> | VirtualizedFile<T>>
const [local, others] = splitProps(props, textKeys)
@@ -821,11 +940,10 @@ function TextViewer<T>(props: TextFileProps<T>) {
const virtual = createMemo(() => lineCount() > virtualizeLineThreshold)
const virtuals = createLocalVirtualStrategy(() => viewer.wrapper, virtual)
const poolReady = createPoolReady()
// Rows that are not drawn yet cannot show a range; the machine keeps it and the ready callback applies it again.
const applySelection = (range: SelectedLineRange | null) => {
const current = instance
const current = render.instance()
if (!current) return
@@ -866,13 +984,11 @@ function TextViewer<T>(props: TextFileProps<T>) {
mode: "text",
enableLineSelection: () => props.enableLineSelection === true,
selectedLines: () => local.selectedLines,
commentedLines: () => local.commentedLines ?? [],
callbacks: local,
lineForElement: parseLine,
lineForNode: findFileLineNumber,
sideForNode: findCodeSelectionSide,
applySelection,
markCommented: markCommentedFileLines,
})
const options = createMemo(() => ({
@@ -881,77 +997,61 @@ function TextViewer<T>(props: TextFileProps<T>) {
...viewer.lineCallbacks,
}))
const notify = () => {
notifyRendered({
viewer,
isReady: (root) => {
if (virtual()) return root.querySelector("[data-line]") != null
return root.querySelectorAll("[data-line]").length >= lineCount()
},
onReady: () => {
viewer.reapplySelection()
viewer.find.refresh({ reset: true })
local.onRendered?.()
},
})
}
useSearchHandle({
search: () => local.search,
find: viewer.find,
})
// -- render instance --
// Cleanups run in reverse, so the instance is cleaned up before the virtualizer it uses.
onCleanup(() => virtuals.cleanup())
createEffect(() => {
const opts = options()
const workerPool = getWorkerPool()
const virtualizer = virtuals.get()
if (virtualizer && !poolReady(workerPool)) return
// An instance keeps the virtualizer it was built with; options and contents update in place.
const reset = instance !== undefined && instanceVirtualizer !== virtualizer
const forceRender = !reset && instance !== undefined && !areOptionsEqual(instance.options, opts)
renderViewer({
viewer,
current: instance,
reset,
create: () =>
virtualizer
? new VirtualizedFile<T>(opts, virtualizer, codeMetrics, workerPool)
: new PierreFile<T>(opts, workerPool),
update: (value) => value.setOptions(opts),
assign: (value) => {
instance = value
instanceVirtualizer = virtualizer
},
draw: (value) => {
value.render({
file: local.file,
forceRender,
lineAnnotations: [],
containerWrapper: viewer.container,
})
},
onReady: notify,
})
})
useAnnotationRerender<LineAnnotation<T>>({
// An instance keeps the virtualizer and pool it was built with; options and contents update in place.
render = useViewerRender({
viewer,
current: () => instance,
options,
request: () => {
const workerPool = getWorkerPool()
return {
spec: {
virtualizer: virtuals.get(),
workerPool,
hunkSeparators: undefined,
target: { kind: "text", file: local.file },
},
pool: readPoolState(workerPool),
settleFrames: 0,
preserveHeight: false,
expectsRows: true,
}
},
create: (spec, opts) =>
spec.virtualizer
? new VirtualizedFile<T>(opts, spec.virtualizer, codeMetrics, spec.workerPool)
: new PierreFile<T>(opts, spec.workerPool),
update: (instance, opts) => {
const forceRender = !areOptionsEqual(instance.options, opts)
instance.setOptions(opts)
return forceRender
},
draw: (instance, spec, forceRender) => {
if (spec.target.kind !== "text") return
instance.render({ file: spec.target.file, forceRender, lineAnnotations: [], containerWrapper: viewer.container })
},
isReady: (root) => {
if (virtual()) return root.querySelector("[data-line]") != null
return root.querySelectorAll("[data-line]").length >= lineCount()
},
annotations: () => local.annotations ?? [],
})
// -- cleanup --
onCleanup(() => {
instance?.cleanUp()
instance = undefined
instanceVirtualizer = undefined
virtuals.cleanup()
applyAnnotations: (instance) => {
instance.setLineAnnotations(local.annotations ?? [])
instance.rerender()
},
commentedLines: () => local.commentedLines ?? [],
markCommented: markCommentedFileLines,
onRendered: () => local.onRendered?.(),
})
return <ViewerShell mode="text" viewer={viewer} class={local.class} classList={local.classList} />
@@ -962,14 +1062,8 @@ function TextViewer<T>(props: TextFileProps<T>) {
// ---------------------------------------------------------------------------
function DiffViewer<T>(props: DiffFileProps<T>) {
let instance: FileDiff<T> | undefined
let instanceVirtualizer: Virtualizer | undefined
let instanceWorkerPool: ReturnType<typeof getWorkerPool>
let instanceVirtualHunkSeparators: FileDiffOptions<T, undefined>["hunkSeparators"] | undefined
let instanceFileDiff: FileDiffMetadata | undefined
let instanceBefore: FileContents | undefined
let instanceAfter: FileContents | undefined
let viewer!: Viewer
let render!: ViewerRender<FileDiff<T>>
const [local, others] = splitProps(props, diffKeys)
@@ -979,11 +1073,11 @@ function DiffViewer<T>(props: DiffFileProps<T>) {
const fixSelection = (range: SelectedLineRange | null) => {
const fixed = fixDiffSelection(viewer.getRoot(), range)
return fixed === null && instance instanceof VirtualizedFileDiff ? range : fixed
return fixed === null && render.instance() instanceof VirtualizedFileDiff ? range : fixed
}
const applySelection = (range: SelectedLineRange | null) => {
const active = instance
const active = render.instance()
if (!active) return
const fixed = fixSelection(range)
@@ -995,7 +1089,6 @@ function DiffViewer<T>(props: DiffFileProps<T>) {
mode: "diff",
enableLineSelection: () => props.enableLineSelection === true,
selectedLines: () => local.selectedLines,
commentedLines: () => local.commentedLines ?? [],
callbacks: local,
lineForElement: findDiffLineNumber,
sideForElement: diffMouseSide,
@@ -1003,7 +1096,6 @@ function DiffViewer<T>(props: DiffFileProps<T>) {
sideForNode: diffSelectionSide,
applySelection,
normalize: fixSelection,
markCommented: markCommentedDiffLines,
})
const virtuals = createSharedVirtualStrategy(
@@ -1011,8 +1103,6 @@ function DiffViewer<T>(props: DiffFileProps<T>) {
() => local.virtualize !== false,
)
const poolReady = createPoolReady()
const large = createMemo(() => {
if (local.fileDiff) {
const before = local.fileDiff.deletionLines.join("")
@@ -1047,178 +1137,122 @@ function DiffViewer<T>(props: DiffFileProps<T>) {
return { ...perf, disableLineNumbers: props.disableLineNumbers ?? true }
})
// A virtualized diff only renders rows near the viewport, so jumping to a selection must scroll it into range first.
let pendingReveal: SelectedLineRange | undefined
const revealSelection = () => {
const active = instance
const range = pendingReveal
if (!active || !range) return
if (!(active instanceof VirtualizedFileDiff) || !instanceVirtualizer) {
pendingReveal = undefined
return
}
const position = active.getLinePosition(Math.min(range.start, range.end), range.side)
const root = instanceVirtualizer.getRoot()
// Keep the request until the diff has a layout to measure; the next render retries it.
if (!position || !root) return
pendingReveal = undefined
const top = instanceVirtualizer.getOffsetInScrollContainer(viewer.container) + position.top
const scrollTop = instanceVirtualizer.getScrollTop()
const height = root instanceof Document ? window.innerHeight : root.clientHeight
if (top >= scrollTop && top + position.height <= scrollTop + height) return
instanceVirtualizer.scrollTo({ top: top - height / 2 })
}
createEffect(
on(
() => local.selectedLines,
(range) => {
pendingReveal = range ?? undefined
revealSelection()
},
),
)
const notify = (done?: VoidFunction) => {
notifyRendered({
viewer,
isReady: (root) => root.querySelector("[data-line]") != null,
settleFrames: 1,
onReady: () => {
done?.()
viewer.reapplySelection()
revealSelection()
viewer.find.refresh({ reset: true })
local.onRendered?.()
},
})
}
useSearchHandle({
search: () => local.search,
find: viewer.find,
})
// -- render instance --
const cacheKey = (contents: string) =>
large() ? sampledChecksum(contents) : sampledChecksum(contents, contents.length)
createEffect(() => {
const opts = options()
// Worker render options override per-viewer options, including the large-file fallback.
const workerPool = getWorkerPool(large() ? "none" : "word-line")
const virtualizer = virtuals.get()
const target = (): ViewerTarget => {
if (local.fileDiff) return { kind: "diff-patch", fileDiff: local.fileDiff }
if (virtualizer && !poolReady(workerPool)) return
const beforeContents = local.before?.contents ?? ""
const afterContents = local.after?.contents ?? ""
const done = preserve(viewer)
if (!local.before || !local.after) return { kind: "diff-empty" }
onCleanup(done)
const cacheKey = (contents: string) => {
if (!large()) return sampledChecksum(contents, contents.length)
return sampledChecksum(contents)
return {
kind: "diff-files",
before: { ...local.before, cacheKey: cacheKey(local.before.contents) },
after: { ...local.after, cacheKey: cacheKey(local.after.contents) },
}
}
const before = local.before
? { ...local.before, contents: beforeContents, cacheKey: cacheKey(beforeContents) }
: undefined
// Cleanups run in reverse, so the instance is cleaned up before it releases the shared virtualizer.
onCleanup(() => virtuals.cleanup())
const after = local.after
? { ...local.after, contents: afterContents, cacheKey: cacheKey(afterContents) }
: undefined
// Pierre beta virtualized instances retain their first diff target and resolve separator metrics at construction.
// Plain timeline diffs keep the instance as content streams; virtualized viewers reset only when that is unsafe.
render = useViewerRender({
viewer,
options,
request: () => {
// Worker render options override per-viewer options, including the large-file fallback.
const workerPool = getWorkerPool(large() ? "none" : "word-line")
const virtualizer = virtuals.get()
const next = target()
const targetChanged =
local.fileDiff !== undefined
? instanceFileDiff !== local.fileDiff
: instanceFileDiff !== undefined ||
before === undefined ||
after === undefined ||
instanceBefore === undefined ||
instanceAfter === undefined ||
!areFilesEqual(instanceBefore, before) ||
!areFilesEqual(instanceAfter, after)
return {
spec: {
virtualizer,
workerPool,
hunkSeparators: virtualizer ? options().hunkSeparators : undefined,
target: next,
},
pool: readPoolState(workerPool),
settleFrames: 1,
preserveHeight: true,
expectsRows: diffExpectsRows(next, options().expandUnchanged),
}
},
create: (spec, opts) =>
spec.virtualizer
? new VirtualizedFileDiff<T>(opts, spec.virtualizer, virtualMetrics, spec.workerPool)
: new FileDiff<T>(opts, spec.workerPool),
update: (instance, opts) => {
const forceRender = !areOptionsEqual(instance.options, opts)
instance.setOptions(opts)
// Pierre beta virtualized instances retain their first diff target and resolve separator metrics at construction.
// Plain timeline diffs can retain the instance as content streams; virtualized viewers reset only when that is unsafe.
const reset =
instance !== undefined &&
(instanceVirtualizer !== virtualizer ||
instanceWorkerPool !== workerPool ||
(virtualizer !== undefined && (instanceVirtualHunkSeparators !== opts.hunkSeparators || targetChanged)))
const forceRender = !reset && instance !== undefined && !areOptionsEqual(instance.options, opts)
renderViewer({
viewer,
current: instance,
reset,
create: () =>
virtualizer
? new VirtualizedFileDiff<T>(opts, virtualizer, virtualMetrics, workerPool)
: new FileDiff<T>(opts, workerPool),
update: (value) => value.setOptions(opts),
assign: (value) => {
instance = value
instanceVirtualizer = virtualizer
instanceWorkerPool = workerPool
instanceVirtualHunkSeparators = virtualizer ? opts.hunkSeparators : undefined
instanceFileDiff = local.fileDiff
instanceBefore = before
instanceAfter = after
},
draw: (value) => {
if (local.fileDiff) {
value.render({
fileDiff: local.fileDiff,
forceRender,
lineAnnotations: [],
containerWrapper: viewer.container,
})
return
}
if (!before || !after) return
value.render({
oldFile: before,
newFile: after,
return forceRender
},
draw: (instance, spec, forceRender) => {
if (spec.target.kind === "diff-patch") {
instance.render({
fileDiff: spec.target.fileDiff,
forceRender,
lineAnnotations: [],
containerWrapper: viewer.container,
})
},
onReady: () => notify(done),
})
})
useAnnotationRerender<DiffLineAnnotation<T>>({
viewer,
current: () => instance,
return
}
if (spec.target.kind !== "diff-files") return
instance.render({
oldFile: spec.target.before,
newFile: spec.target.after,
forceRender,
lineAnnotations: [],
containerWrapper: viewer.container,
})
},
isReady: (root) => root.querySelector("[data-line]") != null,
annotations: () => local.annotations ?? [],
applyAnnotations: (instance) => {
instance.setLineAnnotations(local.annotations ?? [])
instance.rerender()
},
commentedLines: () => local.commentedLines ?? [],
markCommented: markCommentedDiffLines,
// A virtualized diff only renders rows near the viewport, so jumping to a selection must scroll it into range.
reveal: (instance, spec, range) => {
const virtualizer = spec.virtualizer
if (!(instance instanceof VirtualizedFileDiff) || !virtualizer) return true
const position = instance.getLinePosition(Math.min(range.start, range.end), range.side)
const root = virtualizer.getRoot()
// Keep the request until the diff has a layout to measure; the next ready draw retries it.
if (!position || !root) return false
const top = virtualizer.getOffsetInScrollContainer(viewer.container) + position.top
const scrollTop = virtualizer.getScrollTop()
const height = root instanceof Document ? window.innerHeight : root.clientHeight
if (top < scrollTop || top + position.height > scrollTop + height) virtualizer.scrollTo({ top: top - height / 2 })
return true
},
onRendered: () => local.onRendered?.(),
})
// -- cleanup --
onCleanup(() => {
instance?.cleanUp()
instance = undefined
instanceVirtualizer = undefined
instanceWorkerPool = undefined
instanceVirtualHunkSeparators = undefined
instanceFileDiff = undefined
instanceBefore = undefined
instanceAfter = undefined
virtuals.cleanup()
})
createEffect(
on(
() => local.selectedLines,
(range) => render.requestReveal(range ?? undefined),
),
)
return <ViewerShell mode="diff" viewer={viewer} class={local.class} classList={local.classList} />
}
@@ -1,17 +1,3 @@
type ReadyWatcher = {
observer?: MutationObserver
token: number
}
export function createReadyWatcher(): ReadyWatcher {
return { token: 0 }
}
export function clearReadyWatcher(state: ReadyWatcher) {
state.observer?.disconnect()
state.observer = undefined
}
export function getViewerHost(container: HTMLElement | undefined) {
if (!container) return
const host = container.querySelector("diffs-container")
@@ -54,76 +40,3 @@ export function observeViewerScheme(getHost: () => HTMLElement | undefined) {
return () => monitor.disconnect()
}
export function notifyShadowReady(opts: {
state: ReadyWatcher
container: HTMLElement
getRoot: () => ShadowRoot | undefined
isReady: (root: ShadowRoot) => boolean
onReady: () => void
settleFrames?: number
}) {
clearReadyWatcher(opts.state)
opts.state.token += 1
const token = opts.state.token
const settle = Math.max(0, opts.settleFrames ?? 0)
const runReady = () => {
const step = (left: number) => {
if (token !== opts.state.token) return
if (left <= 0) {
opts.onReady()
return
}
requestAnimationFrame(() => step(left - 1))
}
requestAnimationFrame(() => step(settle))
}
const observeRoot = (root: ShadowRoot) => {
if (opts.isReady(root)) {
runReady()
return
}
if (typeof MutationObserver === "undefined") return
clearReadyWatcher(opts.state)
opts.state.observer = new MutationObserver(() => {
if (token !== opts.state.token) return
if (!opts.isReady(root)) return
clearReadyWatcher(opts.state)
runReady()
})
opts.state.observer.observe(root, { childList: true, subtree: true })
}
const root = opts.getRoot()
if (!root) {
if (typeof MutationObserver === "undefined") return
opts.state.observer = new MutationObserver(() => {
if (token !== opts.state.token) return
const next = opts.getRoot()
if (!next) return
observeRoot(next)
})
opts.state.observer.observe(opts.container, { childList: true, subtree: true })
return
}
observeRoot(root)
}
@@ -0,0 +1,292 @@
import { describe, expect, test } from "bun:test"
import { Virtualizer } from "@pierre/diffs"
import type { WorkerPoolManager } from "@pierre/diffs/worker"
import { normalize } from "../components/session-diff"
import {
diffExpectsRows,
DISPOSED_VIEWER_RENDER_STATE,
INITIAL_VIEWER_RENDER_STATE,
needsInstanceReset,
NO_RENDER_EFFECTS,
selectMountedSpec,
transitionViewerRender,
type PoolReadiness,
type ViewerInstanceSpec,
type ViewerRenderEvent,
type ViewerRenderRequest,
type ViewerRenderTransition,
type ViewerTarget,
} from "./render-machine"
// SAFETY: the machine only compares pools by identity; it never calls them.
const poolA = {} as WorkerPoolManager
// SAFETY: as above.
const poolB = {} as WorkerPoolManager
const virtualizer = new Virtualizer()
const files = (before: string, after: string): ViewerTarget => ({
kind: "diff-files",
before: { name: "a.ts", contents: before, cacheKey: before },
after: { name: "a.ts", contents: after, cacheKey: after },
})
const spec = (target: ViewerTarget, change: Partial<ViewerInstanceSpec> = {}): ViewerInstanceSpec => ({
virtualizer: undefined,
workerPool: undefined,
hunkSeparators: undefined,
target,
...change,
})
const requested = (
next: ViewerInstanceSpec,
change: Partial<Omit<ViewerRenderRequest, "spec">> = {},
): ViewerRenderEvent => ({
type: "render.requested",
request: { spec: next, pool: "none", settleFrames: 1, preserveHeight: true, expectsRows: true, ...change },
})
function run(events: ViewerRenderEvent[], state = INITIAL_VIEWER_RENDER_STATE): ViewerRenderTransition {
return events.reduce((result, event) => transitionViewerRender(result.state, event), {
state,
effects: NO_RENDER_EFFECTS,
})
}
const frames = (attempt: number, count: number) =>
Array.from({ length: count }, () => ({ type: "settle.frame", attempt }) as const)
describe("viewer render", () => {
test("an in-place update records the drawn target, so a later virtualized draw compares against it", () => {
const first = spec(files("a1", "b1"))
const second = spec(files("a2", "b2"))
const updated = run([requested(first), requested(second)])
expect(updated.effects).toContainEqual({ type: "draw", action: "update", spec: second })
expect(selectMountedSpec(updated.state)).toBe(second)
const virtualized = run([requested({ ...second, virtualizer })], updated.state)
expect(virtualized.effects).toContainEqual({ type: "draw", action: "reset", spec: { ...second, virtualizer } })
const same = run([requested(spec(files("a2", "b2"), { virtualizer }))], virtualized.state)
expect(same.effects).toContainEqual(expect.objectContaining({ type: "draw", action: "update" }))
const reverted = run([requested(spec(files("a1", "b1"), { virtualizer }))], same.state)
expect(reverted.effects).toContainEqual(expect.objectContaining({ type: "draw", action: "reset" }))
})
test("decides when an instance must be rebuilt", () => {
const text = (contents: string) => ({ kind: "text", file: { name: "a.ts", contents } }) as const
const cases: [ViewerInstanceSpec, ViewerInstanceSpec, boolean][] = [
[spec(text("a")), spec(text("b")), false],
[spec(text("a")), spec(text("a"), { virtualizer }), true],
[spec(text("a"), { workerPool: poolA }), spec(text("a"), { workerPool: poolB }), true],
[spec(files("a", "b")), spec(files("a", "c")), false],
[spec(files("a", "b"), { virtualizer }), spec(files("a", "c"), { virtualizer }), true],
[spec(files("a", "b"), { virtualizer }), spec(files("a", "b"), { virtualizer, hunkSeparators: "simple" }), true],
[spec(files("a", "b"), { virtualizer }), spec(files("a", "b"), { virtualizer }), false],
]
for (const [previous, next, reset] of cases) expect(needsInstanceReset(previous, next)).toBe(reset)
})
test("waits for each pool a virtualized draw needs, even after another pool settled", () => {
const ready = run([requested(spec(files("a", "b"), { virtualizer, workerPool: poolA }), { pool: "ready" })])
expect(ready.state.status).toBe("awaiting-rows")
const large = run(
[requested(spec(files("a", "c"), { virtualizer, workerPool: poolB }), { pool: "initializing" })],
ready.state,
)
expect(large.state).toMatchObject({ status: "awaiting-pool", attempt: 2 })
expect(large.effects).toEqual([{ type: "cancel-async" }, { type: "await-pool", attempt: 2, pool: poolB }])
expect(transitionViewerRender(large.state, { type: "pool.settled", attempt: 1, ok: true }).state).toBe(large.state)
const settled = transitionViewerRender(large.state, { type: "pool.settled", attempt: 2, ok: true })
expect(settled.effects).toContainEqual(
expect.objectContaining({ type: "draw", action: "reset", spec: expect.objectContaining({ workerPool: poolB }) }),
)
})
test("a failed or hung pool falls back to the main thread", () => {
const waiting = run([
requested(spec(files("a", "b"), { virtualizer, workerPool: poolB }), { pool: "initializing" }),
])
const failed = transitionViewerRender(waiting.state, { type: "pool.settled", attempt: 1, ok: false })
expect(selectMountedSpec(failed.state)?.workerPool).toBeUndefined()
const timedOut = transitionViewerRender(waiting.state, { type: "pool.timed-out", attempt: 1 })
expect(selectMountedSpec(timedOut.state)?.workerPool).toBeUndefined()
expect(timedOut.state).toMatchObject({ timedOutPool: poolB })
// The timed-out pool does not block the next draw, until it reports ready.
const next = (pool: PoolReadiness) =>
transitionViewerRender(
timedOut.state,
requested(spec(files("a", "c"), { virtualizer, workerPool: poolB }), { pool }),
)
expect(next("initializing").state.status).toBe("awaiting-rows")
expect(selectMountedSpec(next("initializing").state)?.workerPool).toBeUndefined()
expect(next("ready").state).toMatchObject({ timedOutPool: undefined })
expect(selectMountedSpec(next("ready").state)?.workerPool).toBe(poolB)
const broken = run([requested(spec(files("a", "b"), { virtualizer, workerPool: poolA }), { pool: "broken" })])
expect(selectMountedSpec(broken.state)?.workerPool).toBeUndefined()
})
test("an empty diff settles without waiting for rows and releases the pinned height", () => {
const shown = run([requested(spec(files("a", "b"))), { type: "rows.ready", attempt: 1 }, ...frames(1, 2)])
expect(shown.state).toMatchObject({ status: "ready", heightPinned: false })
const empty = run([requested(spec(files("a", "a")), { expectsRows: false })], shown.state)
expect(empty.effects).toEqual([
{ type: "preserve-height" },
expect.objectContaining({ type: "draw", action: "update" }),
{ type: "sync-annotations" },
{ type: "schedule-settle-frame", attempt: 2 },
])
const settled = run(frames(2, 2), empty.state)
expect(settled.state).toMatchObject({ status: "ready", outcome: "ready", heightPinned: false })
expect(settled.effects).toEqual([
{ type: "release-height" },
{ type: "reapply-selection" },
{ type: "refresh-find" },
{ type: "notify-rendered" },
])
})
test("knows which diffs draw no rows", () => {
const empty = normalize({ file: "a.ts", before: "same\n", after: "same\n", additions: 0, deletions: 0 })
const changed = normalize({ file: "a.ts", before: "a\n", after: "b\n", additions: 1, deletions: 1 })
expect(diffExpectsRows({ kind: "diff-patch", fileDiff: empty.fileDiff }, false)).toBe(false)
expect(diffExpectsRows({ kind: "diff-patch", fileDiff: changed.fileDiff }, false)).toBe(true)
expect(diffExpectsRows(files("same", "same"), false)).toBe(false)
expect(diffExpectsRows(files("same", "same"), true)).toBe(true)
expect(diffExpectsRows({ kind: "diff-empty" }, true)).toBe(false)
})
test("rows that never appear time out, and late rows still finish the draw", () => {
const waiting = run([requested(spec(files("a", "b")))])
const timedOut = transitionViewerRender(waiting.state, { type: "rows.timed-out", attempt: 1 })
expect(timedOut.state).toMatchObject({ status: "ready", outcome: "timeout", heightPinned: false })
expect(timedOut.effects).toEqual([
{ type: "release-height" },
{ type: "reapply-selection" },
{ type: "refresh-find" },
{ type: "notify-rendered" },
])
const late = run([{ type: "rows.ready", attempt: 1 }, ...frames(1, 2)], timedOut.state)
expect(late.state).toMatchObject({ status: "ready", outcome: "ready" })
expect(late.effects).toEqual([{ type: "reapply-selection" }, { type: "refresh-find" }, { type: "notify-rendered" }])
// The next draw stops the row watch the timeout left running.
expect(run([requested(spec(files("a", "c")))], timedOut.state).effects[0]).toEqual({ type: "cancel-async" })
})
test("streamed draws keep the height pinned until the last one settles", () => {
const first = run([requested(spec(files("a", "b")))])
expect(first.effects[0]).toEqual({ type: "preserve-height" })
const second = transitionViewerRender(first.state, requested(spec(files("a", "bc"))))
expect(second.effects).toEqual([
{ type: "cancel-async" },
expect.objectContaining({ type: "draw", action: "update" }),
{ type: "sync-annotations" },
{ type: "watch-rows", attempt: 2 },
])
expect(transitionViewerRender(second.state, { type: "rows.ready", attempt: 1 }).state).toBe(second.state)
const done = run([{ type: "rows.ready", attempt: 2 }, ...frames(2, 1)], second.state)
expect(done.state).toMatchObject({ status: "settling", framesLeft: 1, heightPinned: true })
const ready = run(frames(2, 1), done.state)
expect(ready.effects.filter((effect) => effect.type === "release-height")).toHaveLength(1)
})
test("waits one frame per settle frame plus one, and ignores stale frames", () => {
const quick = run([requested(spec(files("a", "b")), { settleFrames: 0 }), { type: "rows.ready", attempt: 1 }])
expect(transitionViewerRender(quick.state, { type: "settle.frame", attempt: 0 }).state).toBe(quick.state)
expect(run(frames(1, 1), quick.state).state.status).toBe("ready")
const slow = run([requested(spec(files("a", "b"))), { type: "rows.ready", attempt: 1 }])
expect(run(frames(1, 1), slow.state).state.status).toBe("settling")
expect(run(frames(1, 2), slow.state).state.status).toBe("ready")
})
test("annotations apply only when there are some or some were applied since the draw", () => {
expect(transitionViewerRender(INITIAL_VIEWER_RENDER_STATE, { type: "annotations.synced", count: 2 }).effects).toBe(
NO_RENDER_EFFECTS,
)
const drawn = run([requested(spec(files("a", "b")))])
const none = transitionViewerRender(drawn.state, { type: "annotations.synced", count: 0 })
expect(none.state).toBe(drawn.state)
expect(none.effects).toBe(NO_RENDER_EFFECTS)
const added = run([{ type: "annotations.synced", count: 2 }], drawn.state)
expect(added.effects).toEqual([{ type: "apply-annotations" }])
const cleared = run([{ type: "annotations.synced", count: 0 }], added.state)
expect(cleared.effects).toEqual([{ type: "apply-annotations" }])
// A draw renders without annotations, so it syncs them again from scratch.
const redrawn = run([requested(spec(files("a", "c"))), { type: "annotations.synced", count: 0 }], added.state)
expect(redrawn.effects).toBe(NO_RENDER_EFFECTS)
})
test("a reveal waits for a mounted, ready draw and stops once it lands", () => {
const range = { start: 400, end: 400, side: "additions" } as const
const pending = transitionViewerRender(INITIAL_VIEWER_RENDER_STATE, { type: "reveal.requested", range })
expect(pending.effects).toBe(NO_RENDER_EFFECTS)
const ready = run(
[requested(spec(files("a", "b"))), { type: "rows.ready", attempt: 1 }, ...frames(1, 2)],
pending.state,
)
expect(ready.effects).toContainEqual({ type: "try-reveal", range })
const landed = run(
[
{ type: "reveal.completed" },
requested(spec(files("a", "c"))),
{ type: "rows.ready", attempt: 2 },
...frames(2, 2),
],
ready.state,
)
expect(landed.effects).not.toContainEqual(expect.objectContaining({ type: "try-reveal" }))
})
test("disposing releases the height and instance and ignores later results", () => {
const waiting = run([requested(spec(files("a", "b")))])
const disposed = transitionViewerRender(waiting.state, { type: "disposed" })
expect(disposed.state).toBe(DISPOSED_VIEWER_RENDER_STATE)
expect(disposed.effects).toEqual([
{ type: "cancel-async" },
{ type: "release-height" },
{ type: "cleanup-instance" },
])
for (const event of [
{ type: "rows.ready", attempt: 1 },
{ type: "pool.settled", attempt: 1, ok: true },
requested(spec(files("a", "c"))),
] as const)
expect(transitionViewerRender(disposed.state, event).effects).toBe(NO_RENDER_EFFECTS)
})
})
@@ -0,0 +1,381 @@
import {
areFilesEqual,
type FileContents,
type FileDiffMetadata,
type SelectedLineRange,
type Virtualizer,
} from "@pierre/diffs"
import type { WorkerPoolManager } from "@pierre/diffs/worker"
/** A pool that never finishes initializing stops blocking a virtualized viewer after this long. */
export const POOL_INIT_TIMEOUT_MS = 10_000
/** A draw whose rows never appear (an empty diff Pierre renders without rows) settles after this long. */
export const ROWS_READY_TIMEOUT_MS = 2_000
export type PoolReadiness = "none" | "ready" | "initializing" | "broken"
export type ViewerTarget =
| { readonly kind: "text"; readonly file: FileContents }
| { readonly kind: "diff-patch"; readonly fileDiff: FileDiffMetadata }
| { readonly kind: "diff-files"; readonly before: FileContents; readonly after: FileContents }
| { readonly kind: "diff-empty" }
/** What a Pierre instance was built with. A virtualized instance keeps its first target and separators. */
export type ViewerInstanceSpec = {
readonly virtualizer: Virtualizer | undefined
readonly workerPool: WorkerPoolManager | undefined
readonly hunkSeparators: unknown
readonly target: ViewerTarget
}
export type ViewerRenderRequest = {
readonly spec: ViewerInstanceSpec
readonly pool: PoolReadiness
/** Extra frames to wait once rows exist, so a virtualizer can measure them. */
readonly settleFrames: number
/** Pin the container's height while the draw replaces its rows, so the scroller does not jump. */
readonly preserveHeight: boolean
/** Whether the draw produces rows at all; an empty diff settles without waiting for them. */
readonly expectsRows: boolean
}
export type MountedViewer = {
readonly spec: ViewerInstanceSpec
/** Whether the instance currently holds line annotations; each draw renders without them. */
readonly annotated: boolean
}
export type ViewerDrawAction = "create" | "reset" | "update"
type Shared = {
/** Draw count. Events from an earlier draw or pool wait are stale. */
readonly attempt: number
/** Changes on every draw; marks that live in Pierre's shadow DOM are applied again. */
readonly revision: number
readonly heightPinned: boolean
/** A selection to scroll into a virtualized window once rows can be measured. */
readonly reveal: SelectedLineRange | undefined
/** A pool that timed out once; later draws use the main thread until it reports ready. */
readonly timedOutPool: WorkerPoolManager | undefined
}
/**
* One Pierre viewer instance. A virtualized viewer waits for its worker pool before the first draw (`awaiting-pool`);
* each draw then waits for rows (`awaiting-rows`) and a few frames (`settling`) before the viewer reapplies the
* selection, releases the pinned height and reports `ready`. Each wait has a bound.
*/
export type ViewerRenderState =
| (Shared & { readonly status: "idle" })
| (Shared & {
readonly status: "awaiting-pool"
readonly request: ViewerRenderRequest
readonly mounted: MountedViewer | undefined
})
| (Shared & { readonly status: "awaiting-rows"; readonly mounted: MountedViewer; readonly settleFrames: number })
| (Shared & { readonly status: "settling"; readonly mounted: MountedViewer; readonly framesLeft: number })
| (Shared & { readonly status: "ready"; readonly mounted: MountedViewer; readonly outcome: "ready" | "timeout" })
| { readonly status: "disposed" }
export type ViewerRenderEvent =
| { readonly type: "render.requested"; readonly request: ViewerRenderRequest }
| { readonly type: "pool.settled"; readonly attempt: number; readonly ok: boolean }
| { readonly type: "pool.timed-out"; readonly attempt: number }
| { readonly type: "rows.ready"; readonly attempt: number }
| { readonly type: "rows.timed-out"; readonly attempt: number }
| { readonly type: "settle.frame"; readonly attempt: number }
| { readonly type: "annotations.synced"; readonly count: number }
| { readonly type: "reveal.requested"; readonly range: SelectedLineRange | undefined }
| { readonly type: "reveal.completed" }
| { readonly type: "disposed" }
export type ViewerRenderEffect =
| { readonly type: "cancel-async" }
| { readonly type: "await-pool"; readonly attempt: number; readonly pool: WorkerPoolManager }
| { readonly type: "preserve-height" }
| { readonly type: "release-height" }
| { readonly type: "draw"; readonly action: ViewerDrawAction; readonly spec: ViewerInstanceSpec }
| { readonly type: "sync-annotations" }
| { readonly type: "apply-annotations" }
| { readonly type: "watch-rows"; readonly attempt: number }
| { readonly type: "schedule-settle-frame"; readonly attempt: number }
| { readonly type: "reapply-selection" }
| { readonly type: "try-reveal"; readonly range: SelectedLineRange }
| { readonly type: "refresh-find" }
| { readonly type: "notify-rendered" }
| { readonly type: "cleanup-instance" }
export type ViewerRenderTransition = {
readonly state: ViewerRenderState
readonly effects: readonly ViewerRenderEffect[]
}
type Active = Exclude<ViewerRenderState, { status: "disposed" }>
export const NO_RENDER_EFFECTS: readonly ViewerRenderEffect[] = Object.freeze([])
export const INITIAL_VIEWER_RENDER_STATE: ViewerRenderState = Object.freeze({
status: "idle",
attempt: 0,
revision: 0,
heightPinned: false,
reveal: undefined,
timedOutPool: undefined,
})
export const DISPOSED_VIEWER_RENDER_STATE: ViewerRenderState = Object.freeze({ status: "disposed" })
const CANCEL_ASYNC = { type: "cancel-async" } as const
export function transitionViewerRender(state: ViewerRenderState, event: ViewerRenderEvent): ViewerRenderTransition {
if (state.status === "disposed") return { state, effects: NO_RENDER_EFFECTS }
if (event.type === "disposed")
return {
state: DISPOSED_VIEWER_RENDER_STATE,
effects: [
CANCEL_ASYNC,
...(state.heightPinned ? [{ type: "release-height" as const }] : []),
{ type: "cleanup-instance" },
],
}
if (event.type === "render.requested") return request(state, event.request)
if (event.type === "pool.settled" || event.type === "pool.timed-out") {
if (state.status !== "awaiting-pool" || event.attempt !== state.attempt)
return { state, effects: NO_RENDER_EFFECTS }
const pool = state.request.spec.workerPool
// A failed or hung pool falls back to highlighting on the main thread.
if (event.type === "pool.timed-out") return draw({ ...state, timedOutPool: pool }, state.request, undefined)
return draw(state, state.request, event.ok ? pool : undefined)
}
if (event.type === "rows.ready") {
if (event.attempt !== state.attempt) return { state, effects: NO_RENDER_EFFECTS }
if (state.status === "awaiting-rows") return settle(state, state.mounted, state.settleFrames)
// Rows that arrive after the timeout still get the selection, reveal and search a ready draw gets.
if (state.status === "ready" && state.outcome === "timeout") return settle(state, state.mounted, 1)
return { state, effects: NO_RENDER_EFFECTS }
}
if (event.type === "settle.frame") {
if (state.status !== "settling" || event.attempt !== state.attempt) return { state, effects: NO_RENDER_EFFECTS }
if (state.framesLeft > 1)
return {
state: { ...state, framesLeft: state.framesLeft - 1 },
effects: [{ type: "schedule-settle-frame", attempt: state.attempt }],
}
return finish(state, state.mounted, "ready")
}
if (event.type === "rows.timed-out") {
if (state.status !== "awaiting-rows" || event.attempt !== state.attempt)
return { state, effects: NO_RENDER_EFFECTS }
// Release the pinned height and report the draw; the row watch stays in case rows are only slow.
return finish(state, state.mounted, "timeout")
}
if (event.type === "annotations.synced") {
const mounted = selectMounted(state)
// Each draw renders without annotations, so there is nothing to clear when none were applied since.
if (!mounted || (event.count === 0 && !mounted.annotated)) return { state, effects: NO_RENDER_EFFECTS }
const annotated = event.count > 0
return {
state: mounted.annotated === annotated ? state : withMounted(state, { ...mounted, annotated }),
effects: [{ type: "apply-annotations" }],
}
}
if (event.type === "reveal.requested") {
if (state.reveal === event.range) return { state, effects: NO_RENDER_EFFECTS }
return {
state: { ...state, reveal: event.range },
effects: event.range && selectMounted(state) ? [{ type: "try-reveal", range: event.range }] : NO_RENDER_EFFECTS,
}
}
if (state.reveal === undefined) return { state, effects: NO_RENDER_EFFECTS }
return { state: { ...state, reveal: undefined }, effects: NO_RENDER_EFFECTS }
}
function request(state: Active, request: ViewerRenderRequest): ViewerRenderTransition {
const pool = request.spec.workerPool
const timedOutPool = request.pool === "ready" ? undefined : state.timedOutPool
const virtualized = request.spec.virtualizer !== undefined
// A virtualizer that first sees an empty file anchors its bottom edge, then jumps once the pool draws rows.
if (virtualized && request.pool === "initializing" && pool && pool !== timedOutPool) {
const attempt = state.attempt + 1
return {
state: {
status: "awaiting-pool",
attempt,
revision: state.revision,
heightPinned: state.heightPinned,
reveal: state.reveal,
timedOutPool,
request,
mounted: selectMounted(state),
},
effects: [...cancel(state), { type: "await-pool", attempt, pool }],
}
}
const fallback = virtualized && (request.pool === "broken" || (pool !== undefined && pool === timedOutPool))
return draw({ ...state, timedOutPool }, request, fallback ? undefined : pool)
}
function draw(
state: Active,
request: ViewerRenderRequest,
pool: WorkerPoolManager | undefined,
): ViewerRenderTransition {
const spec = pool === request.spec.workerPool ? request.spec : { ...request.spec, workerPool: pool }
const previous = selectMounted(state)
const action = !previous ? "create" : needsInstanceReset(previous.spec, spec) ? "reset" : "update"
const attempt = state.attempt + 1
const mounted = { spec, annotated: false }
const shared = {
attempt,
revision: state.revision + 1,
heightPinned: state.heightPinned || request.preserveHeight,
reveal: state.reveal,
timedOutPool: state.timedOutPool,
}
const effects: ViewerRenderEffect[] = [
...cancel(state),
...(request.preserveHeight && !state.heightPinned ? [{ type: "preserve-height" as const }] : []),
{ type: "draw", action, spec },
{ type: "sync-annotations" },
]
if (!request.expectsRows) {
const next = settle({ ...shared, status: "idle" }, mounted, request.settleFrames)
return { state: next.state, effects: [...effects, ...next.effects] }
}
return {
state: { ...shared, status: "awaiting-rows", mounted, settleFrames: request.settleFrames },
effects: [...effects, { type: "watch-rows", attempt }],
}
}
function settle(state: Active, mounted: MountedViewer, settleFrames: number): ViewerRenderTransition {
return {
state: { ...shared(state), status: "settling", mounted, framesLeft: Math.max(0, settleFrames) + 1 },
effects: [{ type: "schedule-settle-frame", attempt: state.attempt }],
}
}
function finish(state: Active, mounted: MountedViewer, outcome: "ready" | "timeout"): ViewerRenderTransition {
return {
state: { ...shared(state), heightPinned: false, status: "ready", mounted, outcome },
effects: [
...(state.heightPinned ? [{ type: "release-height" as const }] : []),
{ type: "reapply-selection" },
...(state.reveal ? [{ type: "try-reveal" as const, range: state.reveal }] : []),
{ type: "refresh-find" },
{ type: "notify-rendered" },
],
}
}
function cancel(state: Active) {
if (state.status === "idle" || (state.status === "ready" && state.outcome === "ready")) return NO_RENDER_EFFECTS
return [CANCEL_ASYNC]
}
function shared(state: Active) {
return {
attempt: state.attempt,
revision: state.revision,
heightPinned: state.heightPinned,
reveal: state.reveal,
timedOutPool: state.timedOutPool,
}
}
function withMounted(state: Active, mounted: MountedViewer): ViewerRenderState {
if (state.status === "idle") return state
return { ...state, mounted }
}
function selectMounted(state: ViewerRenderState) {
return state.status === "idle" || state.status === "disposed" ? undefined : state.mounted
}
export function readPoolState(pool: WorkerPoolManager | undefined): PoolReadiness {
if (!pool) return "none"
if (pool.isInitialized()) return "ready"
return pool.isWorkingPool() ? "initializing" : "broken"
}
/**
* Whether an instance must be rebuilt rather than updated in place. Instances keep the virtualizer and pool they were
* built with; a virtualized diff also keeps its first target and hunk separators.
*/
export function needsInstanceReset(previous: ViewerInstanceSpec, next: ViewerInstanceSpec) {
if (previous.virtualizer !== next.virtualizer || previous.workerPool !== next.workerPool) return true
if (next.virtualizer === undefined) return false
return previous.hunkSeparators !== next.hunkSeparators || targetChanged(previous.target, next.target)
}
function targetChanged(previous: ViewerTarget, next: ViewerTarget) {
if (previous.kind === "diff-patch" && next.kind === "diff-patch") return previous.fileDiff !== next.fileDiff
if (previous.kind === "diff-files" && next.kind === "diff-files")
return !areFilesEqual(previous.before, next.before) || !areFilesEqual(previous.after, next.after)
return previous.kind !== next.kind
}
/** Whether Pierre draws any rows for this diff. */
export function diffExpectsRows(target: ViewerTarget, expandUnchanged: boolean | undefined) {
if (target.kind === "diff-empty") return false
if (target.kind === "diff-patch")
return (
target.fileDiff.hunks.length > 0 ||
(expandUnchanged === true && target.fileDiff.additionLines.length + target.fileDiff.deletionLines.length > 0)
)
if (target.kind === "diff-files") {
if (expandUnchanged === true) return target.before.contents.length + target.after.contents.length > 0
return target.before.contents !== target.after.contents
}
return true
}
export function selectRevision(state: ViewerRenderState) {
return state.status === "disposed" ? 0 : state.revision
}
export function selectMountedSpec(state: ViewerRenderState) {
return selectMounted(state)?.spec
}