@xynogen/pix-pretty 1.16.0 → 1.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.16.0",
+	"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

@@ -31,6 +31,23 @@ class MockTextComponent {
 	invalidate(): void {}
 }
 
+// Counting variant: records how often the inner component is re-fitted, so a
+// 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 {}
+}
+
 describe("viewportText", () => {
 	it("trims a pre-filled row to Pi's narrower fullscreen viewport", () => {
 		const text = viewportText(MockTextComponent);
@@ -39,6 +56,101 @@ describe("viewportText", () => {
 		expect(plain(text.render(9)[0]!)).toBe("tool".padEnd(9));
 		expect(plain(text.render(10)[0]!)).toBe("tool".padEnd(10));
 	});
+
+	it("memoizes: repeat render at same width does not re-fit the inner component", () => {
+		CountingTextComponent.setCalls = 0;
+		const text = viewportText(CountingTextComponent);
+		text.setText("line one\nline two");
+
+		text.render(20);
+		text.render(20);
+		text.render(20);
+		// One fit for the width; repeats hit the cache. Pre-memo this was 3.
+		expect(CountingTextComponent.setCalls).toBe(1);
+	});
+
+	it("re-fits when width changes, and again when it returns", () => {
+		CountingTextComponent.setCalls = 0;
+		const text = viewportText(CountingTextComponent);
+		text.setText("abcdefghij");
+
+		text.render(20);
+		text.render(5); // width changed → re-fit
+		text.render(5); // same → cached
+		text.render(20); // changed back → re-fit
+		expect(CountingTextComponent.setCalls).toBe(3);
+	});
+
+	it("re-fits after setText changes the content", () => {
+		CountingTextComponent.setCalls = 0;
+		const text = viewportText(CountingTextComponent);
+		text.setText("first");
+		text.render(20);
+		text.render(20); // cached
+		text.setText("second"); // invalidates memo
+		text.render(20); // re-fit
+		expect(CountingTextComponent.setCalls).toBe(2);
+	});
+
+	it("setText with identical value is a no-op (no memo invalidation)", () => {
+		CountingTextComponent.setCalls = 0;
+		const text = viewportText(CountingTextComponent);
+		text.setText("same");
+		text.render(20);
+		text.setText("same"); // identical → must not invalidate
+		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,12 +71,33 @@ type ViewportComponent = {
 
 class ViewportText implements TextComponentLike, ViewportComponent {
 	private text = "";
+	// 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.component.setText(value);
+		this.fittedWidth = -1; // invalidate blob memo (line cache stays valid)
+		this.renderedWidth = -1; // invalidate render-output memo
 	}
 
 	getText(): string {
@@ -84,15 +105,46 @@ class ViewportText implements TextComponentLike, ViewportComponent {
 	}
 
 	render(width: number): string[] {
-		const fitted = this.text
-			.split("\n")
-			.map((line) => truncateToWidth(line, width, ""))
-			.join("\n");
-		this.component.setText(fitted);
-		return this.component.render?.(width) ?? fitted.split("\n");
+		if (width !== this.fittedWidth) {
+			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);
+		}
+		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?.();
 	}
 }