@xynogen/pix-pretty 1.16.1 → 1.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.16.1",
+	"version": "1.16.2",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, diff rendering, and FFF search",
 	"type": "module",
 	"main": "src/index.ts",

package/src/utils.test.ts

@@ -35,12 +35,14 @@ class MockTextComponent {
 // regression that recomputes every frame (the pre-memo CPU bug) fails loudly.
 class CountingTextComponent {
 	static setCalls = 0;
+	static renderCalls = 0;
 	private text = "";
 	setText(value: string): void {
 		CountingTextComponent.setCalls++;
 		this.text = value;
 	}
 	render(): string[] {
+		CountingTextComponent.renderCalls++;
 		return this.text.split("\n");
 	}
 	invalidate(): void {}
@@ -99,6 +101,56 @@ describe("viewportText", () => {
 		text.render(20); // still cached
 		expect(CountingTextComponent.setCalls).toBe(1);
 	});
+
+	it("idle frames (same text+width) do not re-call the inner render", () => {
+		CountingTextComponent.renderCalls = 0;
+		const text = viewportText(CountingTextComponent);
+		text.setText("line one\nline two");
+		text.render(20);
+		text.render(20);
+		text.render(20);
+		// One inner render for the width; spinner ticks reuse the memoized output.
+		expect(CountingTextComponent.renderCalls).toBe(1);
+	});
+
+	it("re-calls inner render after content changes", () => {
+		CountingTextComponent.renderCalls = 0;
+		const text = viewportText(CountingTextComponent);
+		text.setText("first");
+		text.render(20);
+		text.setText("second"); // content changed → render output stale
+		text.render(20);
+		expect(CountingTextComponent.renderCalls).toBe(2);
+	});
+
+	it("invalidate() drops the render memo so a same-width frame recomputes (theme change)", () => {
+		CountingTextComponent.renderCalls = 0;
+		const text = viewportText(CountingTextComponent);
+		text.setText("body");
+		text.render(20);
+		text.render(20); // memo hit
+		expect(CountingTextComponent.renderCalls).toBe(1);
+		text.invalidate(); // theme/style changed → output stale even at same width
+		text.render(20); // must recompute, not serve pre-invalidate output
+		expect(CountingTextComponent.renderCalls).toBe(2);
+	});
+
+	it("streaming append reuses already-fitted lines and fits only the new tail", () => {
+		const text = viewportText(MockTextComponent);
+		text.setText("aaaaaaaaaa\nbbbbbbbbbb");
+		expect(text.render(5).map(plain)).toEqual(["aaaaa", "bbbbb"]);
+		// Append (streaming). Old lines fit identically; new line appears.
+		text.setText("aaaaaaaaaa\nbbbbbbbbbb\ncccccccccc");
+		expect(text.render(5).map(plain)).toEqual(["aaaaa", "bbbbb", "ccccc"]);
+	});
+
+	it("width change re-fits all lines (line cache is width-scoped, no stale serve)", () => {
+		const text = viewportText(MockTextComponent);
+		text.setText("abcdefghij");
+		expect(text.render(5).map(plain)).toEqual(["abcde"]);
+		// Must NOT serve the stale 5-wide fit for the same raw line at a new width.
+		expect(text.render(8).map(plain)).toEqual(["abcdefgh"]);
+	});
 });
 
 // Strip ANSI escapes so assertions test content, not color codes.

package/src/utils.ts

@@ -71,18 +71,33 @@ type ViewportComponent = {
 
 class ViewportText implements TextComponentLike, ViewportComponent {
 	private text = "";
-	// Pi re-renders every frame (spinner/streaming). Without this cache each
-	// frame re-split + re-truncated the full text AND re-setText'd the inner
-	// component (re-dirtying it), burning CPU on unchanged content.
+	// Pi re-renders every frame (spinner/streaming). Two-level cache:
+	//  1. per-line: `truncateToWidth` result keyed by raw line + width. Streaming
+	//     only appends to the tail, so already-fitted lines hit the cache and
+	//     only the new/changed lines pay the pi-tui width cost (was O(total
+	//     lines) per chunk, now O(new lines)).
+	//  2. per-blob: skip re-joining + re-setText'ing the inner component when
+	//     neither text nor width changed (idle frames, spinner ticks).
 	private fittedWidth = -1;
 	private fittedText = "";
+	private lineCache = new Map<string, string>();
+	private lineCacheWidth = -1;
+	// Render-output memo. The inner component's render is a pure function of
+	// (fittedText, width), so on an unchanged frame (spinner tick, idle) we skip
+	// calling into pi-tui AND skip the fallback split — otherwise both fired
+	// every single frame even when nothing changed. The returned array is shared
+	// by reference; pi-tui's render contract is read-only (the host joins/prints
+	// the lines, never mutates), so we don't defensively copy per frame.
+	private rendered: string[] = [];
+	private renderedWidth = -1;
 
 	constructor(private readonly component: TextComponentLike) {}
 
 	setText(value: string): void {
 		if (value === this.text) return;
 		this.text = value;
-		this.fittedWidth = -1; // invalidate memo
+		this.fittedWidth = -1; // invalidate blob memo (line cache stays valid)
+		this.renderedWidth = -1; // invalidate render-output memo
 	}
 
 	getText(): string {
@@ -91,17 +106,45 @@ class ViewportText implements TextComponentLike, ViewportComponent {
 
 	render(width: number): string[] {
 		if (width !== this.fittedWidth) {
-			this.fittedText = this.text
-				.split("\n")
-				.map((line) => truncateToWidth(line, width, ""))
+			if (width !== this.lineCacheWidth) {
+				this.lineCache.clear(); // width changed → every line must re-fit
+				this.lineCacheWidth = width;
+			}
+			const cache = this.lineCache;
+			const lines = this.text.split("\n");
+			// Bound the cache so a long streaming log can't grow it without limit.
+			// The working set is the visible line count; a generous multiple keeps
+			// steady-state hits while capping worst-case memory. Reset when exceeded
+			// rather than LRU-evicting — simpler, and a width-stable frame refills it.
+			if (cache.size > 4 * lines.length + 256) cache.clear();
+			this.fittedText = lines
+				.map((line) => {
+					let fitted = cache.get(line);
+					if (fitted === undefined) {
+						fitted = truncateToWidth(line, width, "");
+						cache.set(line, fitted);
+					}
+					return fitted;
+				})
 				.join("\n");
 			this.fittedWidth = width;
+			this.renderedWidth = -1; // fitted text rebuilt → render output is stale
 			this.component.setText(this.fittedText);
 		}
-		return this.component.render?.(width) ?? this.fittedText.split("\n");
+		if (width !== this.renderedWidth) {
+			this.rendered = this.component.render?.(width) ?? this.fittedText.split("\n");
+			this.renderedWidth = width;
+		}
+		return this.rendered;
 	}
 
 	invalidate(): void {
+		// invalidate = "output stale for reasons other than (text,width)" — theme /
+		// style change. Fitting is pure on (text,width) so fittedText/lineCache stay
+		// valid, but the RENDER output (colors) may differ, so drop the render memo;
+		// otherwise a same-width frame after invalidate would serve pre-invalidate
+		// output forever.
+		this.renderedWidth = -1;
 		this.component.invalidate?.();
 	}
 }