Add Static component for rendering permanent output

mosaic-runtime/src/main/kotlin/com/jakewharton/mosaic/Static.kt

@@ -0,0 +1,108 @@
+package com.jakewharton.mosaic
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.ComposeNode
+import androidx.compose.runtime.DisallowComposableCalls
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.remember
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+
+/**
+ * Will render each value emitted by [items] as permanent output above the
+ * regular display.
+ */
+@Composable
+fun <T> Static(
+	items: Flow<T>,
+	content: @Composable (T) -> Unit,
+) {
+	class Item(val value: T, var rendered: Boolean)
+
+	// Keep list of items which have not yet been rendered.
+	val pending = remember { mutableStateListOf<Item>() }
+
+	LaunchedEffect(items) {
+		items.collect {
+			pending.add(Item(it, rendered = false))
+		}
+	}
+
+	Static(
+		postRender = {
+			// Remove any items which have been rendered.
+			pending.removeIf { it.rendered }
+		}
+	) {
+		for (item in pending) {
+			Row {
+				// Render item and mark it as having been included in render.
+				content(item.value)
+				item.rendered = true
+			}
+		}
+	}
+}
+
+/**
+ * Renders [content] permanently above the normal canvas. When content has
+ * actually been written to a [TextCanvas], the [postRender] callback will be
+ * invoked to allow clearing of content.
+ *
+ * @param postRender Callback after rendering to a [TextCanvas] is complete.
+ * @param content Content which should be rendered permanently above normal
+ * canvas.
+ */
+@Composable
+internal fun Static(
+	postRender: () -> Unit = {},
+	content: @Composable () -> Unit,
+) {
+	ComposeNode<StaticNode, MosaicNodeApplier>(
+		factory = ::StaticNode,
+		update = {
+			set(postRender) {
+				this.postRender = postRender
+			}
+		},
+		content = content,
+	)
+}
+
+internal class StaticNode : ContainerNode() {
+	// Delegate container column for static content.
+	private val box = BoxNode().also {
+		it.isRow = false
+	}
+
+	override val children: MutableList<MosaicNode>
+		get() = box.children
+
+	var postRender: () -> Unit = {}
+
+	override fun measure() {
+		// Not visible.
+	}
+
+	override fun layout() {
+		// Not visible.
+	}
+
+	override fun renderTo(canvas: TextCanvas) {
+		// Render contents of static node to a separate display.
+		val other = box.render()
+
+		// Add display canvas to static canvases if it is not empty.
+		if (other.width > 0 && other.height > 0) {
+			canvas.static.add(other)
+		}
+
+		// Propagate any static content of the display.
+		canvas.static.addAll(other.static)
+
+		postRender()
+	}
+
+	override fun toString() = box.children.joinToString(prefix = "Static(", postfix = ")")
+}

mosaic-runtime/src/main/kotlin/com/jakewharton/mosaic/canvas.kt

@@ -12,6 +12,9 @@ internal interface TextCanvas {
 	val width: Int
 	val height: Int
 
+	/** Separate canvases for [static][StaticNode] content. */
+	val static: MutableList<TextCanvas>
+
 	operator fun get(row: Int, column: Int): TextCodepoint
 
 	operator fun get(row: Int, columns: IntRange) = get(row..row, columns)
@@ -30,6 +33,10 @@ internal interface TextCanvas {
 		return ClippedTextCanvas(this, left, top, right, bottom)
 	}
 
+	fun empty(): TextCanvas {
+		return ClippedTextCanvas(this, 0, 0, -1, -1)
+	}
+
 	fun write(
 		row: Int,
 		column: Int,
@@ -87,6 +94,9 @@ internal class ClippedTextCanvas(
 	override val width = right - left + 1
 	override val height = bottom - top + 1
 
+	override val static: MutableList<TextCanvas>
+		get() = delegate.static
+
 	override fun get(row: Int, column: Int): TextCodepoint {
 		require(row in 0 until height) { "Row value out of range [0,$height): $row"}
 		require(column in 0 until width) { "Column value out of range [0,$width): $column"}
@@ -113,6 +123,8 @@ internal class TextSurface(
 ) : TextCanvas {
 	private val rows = Array(height) { Array(width) { TextCodepoint(' ') } }
 
+	override val static = mutableListOf<TextCanvas>()
+
 	override operator fun get(row: Int, column: Int) = rows[row][column]
 
 	override fun toString() = render()

mosaic-runtime/src/main/kotlin/com/jakewharton/mosaic/nodes.kt

@@ -19,12 +19,12 @@ internal sealed class MosaicNode {
 	abstract fun layout()
 	abstract fun renderTo(canvas: TextCanvas)
 
-	fun render(): String {
+	fun render(): TextCanvas {
 		measure()
 		layout()
 		val canvas = TextSurface(width, height)
 		renderTo(canvas)
-		return canvas.toString()
+		return canvas
 	}
 }
 
@@ -62,8 +62,13 @@ internal class TextNode(initialValue: String = "") : MosaicNode() {
 	override fun toString() = "Text(\"$value\", x=$x, y=$y, width=$width, height=$height)"
 }
 
-internal class BoxNode : MosaicNode() {
-	val children = mutableListOf<MosaicNode>()
+internal sealed class ContainerNode : MosaicNode() {
+	abstract val children: MutableList<MosaicNode>
+}
+
+internal class BoxNode : ContainerNode() {
+	override val children = mutableListOf<MosaicNode>()
+
 	/** If row, otherwise column. */
 	var isRow = true
 
@@ -135,6 +140,8 @@ internal class BoxNode : MosaicNode() {
 				val right = left + child.width - 1
 				val bottom = top + child.height - 1
 				child.renderTo(canvas[top..bottom, left..right])
+			} else {
+				child.renderTo(canvas.empty())
 			}
 		}
 	}
@@ -148,22 +155,22 @@ internal class MosaicNodeApplier(root: BoxNode) : AbstractApplier<MosaicNode>(ro
 	}
 
 	override fun insertBottomUp(index: Int, instance: MosaicNode) {
-		val boxNode = current as BoxNode
+		val boxNode = current as ContainerNode
 		boxNode.children.add(index, instance)
 	}
 
 	override fun remove(index: Int, count: Int) {
-		val boxNode = current as BoxNode
+		val boxNode = current as ContainerNode
 		boxNode.children.remove(index, count)
 	}
 
 	override fun move(from: Int, to: Int, count: Int) {
-		val boxNode = current as BoxNode
+		val boxNode = current as ContainerNode
 		boxNode.children.move(from, to, count)
 	}
 
 	override fun onClear() {
-		val boxNode = root as BoxNode
+		val boxNode = root as ContainerNode
 		boxNode.children.clear()
 	}
 }

mosaic-runtime/src/main/kotlin/com/jakewharton/mosaic/output.kt

@@ -5,13 +5,13 @@ import java.nio.charset.StandardCharsets.UTF_8
 import java.util.concurrent.TimeUnit.NANOSECONDS
 
 internal interface Output {
-	fun display(output: String)
+	fun display(canvas: TextCanvas)
 }
 
 internal object DebugOutput : Output {
 	private var lastRenderNanos = 0L
 
-	override fun display(output: String) {
+	override fun display(canvas: TextCanvas) {
 		println(buildString {
 			val renderNanos = System.nanoTime()
 
@@ -24,30 +24,34 @@ internal object DebugOutput : Output {
 			}
 			lastRenderNanos = renderNanos
 
-			appendLine(output)
+			for (static in canvas.static) {
+				appendLine(static.render())
+			}
+
+			appendLine(canvas.render())
 		})
 	}
 }
 
 internal object AnsiOutput : Output {
 	private var lastHeight = 0
 
-	override fun display(output: String) {
+	override fun display(canvas: TextCanvas) {
 		val rendered = buildString {
-			val lines = output.split("\n")
-
 			repeat(lastHeight) {
 				append("\u001B[F") // Cursor up line.
 			}
 
-			for (line in lines) {
+			val staticLines = canvas.static.flatMap { it.render().split("\n") }
+			val lines = canvas.render().split("\n")
+			for (line in staticLines + lines) {
 				append(line)
 				append("\u001B[K") // Clear rest of line.
 				append('\n')
 			}
 
 			// If the new output contains fewer lines than the last output, clear those old lines.
-			val extraLines = lastHeight - lines.size
+			val extraLines = lastHeight - (lines.size + staticLines.size)
 			for (i in 0 until extraLines) {
 				if (i > 0) {
 					append('\n')