@pi-archimedes/diff 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/diff",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "keywords": [
     "pi-package"

package/src/ansi/codes.ts

@@ -54,18 +54,6 @@ export const DEFAULT_DIFF_BG: DiffBg = {
 	divider: `${FG_RULE}│\x1b[0m`,
 };
 
-// Legacy aliases — used by word-diff.ts during transition. Will be removed.
-// These MUST be mutable and live in the same module as the functions that mutate them.
-export let BG_ADD = DEFAULT_DIFF_BG.bgAdd;
-export let BG_DEL = DEFAULT_DIFF_BG.bgDel;
-export let BG_ADD_W = DEFAULT_DIFF_BG.bgAddW;
-export let BG_DEL_W = DEFAULT_DIFF_BG.bgDelW;
-export let BG_GUTTER_ADD = DEFAULT_DIFF_BG.bgGutterAdd;
-export let BG_GUTTER_DEL = DEFAULT_DIFF_BG.bgGutterDel;
-export let BG_EMPTY = DEFAULT_DIFF_BG.bgEmpty;
-export let BG_BASE = DEFAULT_DIFF_BG.bgBase;
-export let DIVIDER = DEFAULT_DIFF_BG.divider;
-
 // Theme cache key state — lives here since it's used by resolveDiffColors.
 let _lastThemeKey: string | undefined;
 
@@ -91,21 +79,12 @@ export interface DiffColors {
 export const DEFAULT_DIFF_COLORS: DiffColors = { fgAdd: FG_ADD, fgDel: FG_DEL, fgCtx: FG_DIM };
 
 // ---------------------------------------------------------------------------
-// Theme-aware color resolution (mutates legacy aliases)
+// Theme-aware color resolution
 // ---------------------------------------------------------------------------
 
 /** Reset auto-derived colors — call when theme changes. */
 export function resetDiffColors(): void {
 	_lastThemeKey = undefined;
-	BG_ADD = DEFAULT_DIFF_BG.bgAdd;
-	BG_DEL = DEFAULT_DIFF_BG.bgDel;
-	BG_ADD_W = DEFAULT_DIFF_BG.bgAddW;
-	BG_DEL_W = DEFAULT_DIFF_BG.bgDelW;
-	BG_GUTTER_ADD = DEFAULT_DIFF_BG.bgGutterAdd;
-	BG_GUTTER_DEL = DEFAULT_DIFF_BG.bgGutterDel;
-	BG_EMPTY = DEFAULT_DIFF_BG.bgEmpty;
-	BG_BASE = DEFAULT_DIFF_BG.bgBase;
-	DIVIDER = DEFAULT_DIFF_BG.divider;
 }
 
 export function themeCacheKey(theme?: any): string {
@@ -130,18 +109,8 @@ export { deriveBgFromTheme };
 export function resolveDiffColors(theme?: any): DiffColors {
 	const themeKey = themeCacheKey(theme);
 
-	// Re-derive when theme changes (different key) or first call
-	if (themeKey !== _lastThemeKey && theme?.getFgAnsi) {
-		const dbg = deriveBgFromTheme(theme);
-		BG_ADD = dbg.bgAdd;
-		BG_DEL = dbg.bgDel;
-		BG_ADD_W = dbg.bgAddW;
-		BG_DEL_W = dbg.bgDelW;
-		BG_GUTTER_ADD = dbg.bgGutterAdd;
-		BG_GUTTER_DEL = dbg.bgGutterDel;
-		BG_EMPTY = dbg.bgEmpty;
-		BG_BASE = dbg.bgBase;
-		DIVIDER = dbg.divider;
+	// Re-derive theme key cache (bg colors are now passed explicitly via DiffBg)
+	if (themeKey !== _lastThemeKey) {
 		_lastThemeKey = themeKey;
 	}
 	if (!theme?.getFgAnsi) return DEFAULT_DIFF_COLORS;

package/src/ansi/index.ts

@@ -5,7 +5,6 @@ export {
 	FG_ADD, FG_DEL, FG_DIM, FG_LNUM, FG_RULE, FG_SAFE_MUTED, FG_STRIPE,
 	BORDER_BAR,
 	DEFAULT_DIFF_BG,
-	BG_ADD, BG_DEL, BG_ADD_W, BG_DEL_W, BG_GUTTER_ADD, BG_GUTTER_DEL, BG_EMPTY, BG_BASE, DIVIDER,
 	ANSI_RE, ANSI_CAPTURE_RE, ANSI_PARAM_CAPTURE_RE,
 	DEFAULT_DIFF_COLORS,
 	resetDiffColors, themeCacheKey, resolveDiffColors,

package/src/core/diff.ts

@@ -15,6 +15,10 @@ export interface ParsedDiff {
 }
 
 export function parseDiff(oldContent: string, newContent: string, ctx = 3): ParsedDiff {
+	// Early return for identical content — skip expensive diff computation
+	if (oldContent === newContent) {
+		return { lines: [], added: 0, removed: 0, chars: 0 };
+	}
 	const patch = Diff.structuredPatch("", "", oldContent, newContent, "", "", { context: ctx });
 	const lines: DiffLine[] = [];
 	let added = 0;

package/src/diff-component.ts

@@ -42,8 +42,7 @@ import type { ParsedDiff } from "./core/diff.js";
 export class DiffComponent implements Component {
 	private diff: ParsedDiff;
 	private language: BundledLanguage | undefined;
-	private dc: DiffColors;
-	private dbg: DiffBg;
+	private theme: Theme;
 	private maxLines: number;
 
 	/** Box wrapper with base background — makes the diff self-contained. */
@@ -58,6 +57,9 @@ export class DiffComponent implements Component {
 	/** Final cached output (box-wrapped). */
 	private _cachedLines: string[] | undefined;
 
+	/** Theme cache key — invalidates derived colors on theme change. */
+	private _themeKey: string | undefined;
+
 	constructor(
 		diff: ParsedDiff,
 		language: BundledLanguage | undefined,
@@ -66,12 +68,31 @@ export class DiffComponent implements Component {
 	) {
 		this.diff = diff;
 		this.language = language;
-		this.dc = Ansi.resolveDiffColors(theme);
-		this.dbg = deriveBgFromTheme(theme);
+		this.theme = theme;
 		this.maxLines = maxLines;
 
 		// Box provides base background so the diff is self-contained.
-		this.shell = new Box(0, 0, (s: string) => this.dbg.bgBase + s + this.dbg.rst);
+		// Background function is re-derived on each render via _deriveBg().
+		this.shell = new Box(0, 0, (s: string) => this._deriveBg().bgBase + s + this._deriveBg().rst);
+	}
+
+	/** Re-derive colors from the current theme — handles theme changes. */
+	private _deriveColors(): { dc: DiffColors; dbg: DiffBg } {
+		const themeKey = Ansi.themeCacheKey(this.theme);
+		if (themeKey === this._themeKey && this._cachedDc && this._cachedDbg) {
+			return { dc: this._cachedDc, dbg: this._cachedDbg };
+		}
+		this._themeKey = themeKey;
+		this._cachedDc = Ansi.resolveDiffColors(this.theme);
+		this._cachedDbg = deriveBgFromTheme(this.theme);
+		return { dc: this._cachedDc, dbg: this._cachedDbg };
+	}
+
+	private _cachedDc: DiffColors | undefined;
+	private _cachedDbg: DiffBg | undefined;
+
+	private _deriveBg(): DiffBg {
+		return this._deriveColors().dbg;
 	}
 
 	render(width: number): string[] {
@@ -96,13 +117,14 @@ export class DiffComponent implements Component {
 		}
 
 		// Start async render for this width
+		const { dc, dbg } = this._deriveColors();
 		const promise = renderSplitLines(
 			this.diff,
 			this.language,
 			width,
 			this.maxLines,
-			this.dc,
-			this.dbg,
+			dc,
+			dbg,
 		);
 		this._renderPromise = promise;
 
@@ -135,5 +157,8 @@ export class DiffComponent implements Component {
 	invalidate(): void {
 		this._cachedWidth = undefined;
 		this._cachedLines = undefined;
+		this._themeKey = undefined; // Force re-derive on theme change
+		this._cachedDc = undefined;
+		this._cachedDbg = undefined;
 	}
 }

package/src/index.ts

@@ -11,6 +11,7 @@ import { setConfigGetter as setShikiConfig } from "./shiki.js";
 import { setConfigGetter as setRenderConfig } from "./render/index.js";
 import { DiffComponent } from "./diff-component.js";
 import type { DiffBg, DiffColors } from "./ansi/index.js";
+import { resetDiffColors } from "./ansi/index.js";
 import { registerWriteTool, registerEditTool } from "./tools/index.js";
 
 // ---------------------------------------------------------------------------
@@ -78,6 +79,9 @@ export function registerDiffTools(
 ): void {
 	_readConfig = readConfig;
 
+	// Reset theme-derived colors so they are re-derived from the current theme
+	resetDiffColors();
+
 	// Wire config getters into submodules
 	setShikiConfig(() => getConfig());
 	setRenderConfig(() => getConfig());

package/src/render/split.ts

@@ -34,20 +34,7 @@ export async function renderSplit(
 	dc: DiffColors = DEFAULT_DIFF_COLORS,
 ): Promise<string> {
 	const width = process.stdout.columns ?? DEFAULT_TERM_WIDTH;
-	// Build DiffBg from current (possibly theme-derived) global aliases.
-	const dbg: DiffBg = {
-		bgAdd: Ansi.BG_ADD,
-		bgDel: Ansi.BG_DEL,
-		bgAddW: Ansi.BG_ADD_W,
-		bgDelW: Ansi.BG_DEL_W,
-		bgGutterAdd: Ansi.BG_GUTTER_ADD,
-		bgGutterDel: Ansi.BG_GUTTER_DEL,
-		bgEmpty: Ansi.BG_EMPTY,
-		bgBase: Ansi.BG_BASE,
-		rst: Ansi.BG_BASE === "\x1b[49m" ? "\x1b[0m" : `\x1b[0m${Ansi.BG_BASE}`,
-		divider: Ansi.DIVIDER,
-	};
-	const lines = await renderSplitLines(diff, language, width, max, dc, dbg);
+	const lines = await renderSplitLines(diff, language, width, max, dc, DEFAULT_DIFF_BG);
 	return lines.join("\n");
 }
 
@@ -160,7 +147,7 @@ export async function renderSplitLines(
 			lResult = half_build(leftLine, lhl, wd.oldRanges, "left");
 			rResult = half_build(rightLine, rhl, wd.newRanges, "right");
 		} else if (paired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && !canHL) {
-			const pwd = plainWordDiff(leftLine.content, rightLine.content);
+			const pwd = plainWordDiff(leftLine.content, rightLine.content, dbg);
 			lI++; rI++;
 			lResult = half_build(leftLine, pwd.old, null, "left");
 			rResult = half_build(rightLine, pwd.new, null, "right");

package/src/render/unified.ts

@@ -31,20 +31,7 @@ export async function renderUnified(
 	dc: DiffColors = DEFAULT_DIFF_COLORS,
 ): Promise<string> {
 	const width = process.stdout.columns ?? DEFAULT_TERM_WIDTH;
-	// Build DiffBg from current (possibly theme-derived) global aliases.
-	const dbg: DiffBg = {
-		bgAdd: Ansi.BG_ADD,
-		bgDel: Ansi.BG_DEL,
-		bgAddW: Ansi.BG_ADD_W,
-		bgDelW: Ansi.BG_DEL_W,
-		bgGutterAdd: Ansi.BG_GUTTER_ADD,
-		bgGutterDel: Ansi.BG_GUTTER_DEL,
-		bgEmpty: Ansi.BG_EMPTY,
-		bgBase: Ansi.BG_BASE,
-		rst: Ansi.BG_BASE === "\x1b[49m" ? "\x1b[0m" : `\x1b[0m${Ansi.BG_BASE}`,
-		divider: Ansi.DIVIDER,
-	};
-	const lines = await renderUnifiedLines(diff, language, width, max, dc, dbg);
+	const lines = await renderUnifiedLines(diff, language, width, max, dc, DEFAULT_DIFF_BG);
 	return lines.join("\n");
 }
 
@@ -135,7 +122,7 @@ export async function renderUnifiedLines(
 			continue;
 		}
 		if (isPaired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && !canHL) {
-			const pwd = plainWordDiff(dels[0]!.l.content, adds[0]!.l.content);
+			const pwd = plainWordDiff(dels[0]!.l.content, adds[0]!.l.content, dbg);
 			emitRow(dels[0]!.l.oldNum, "-", dbg.bgGutterDel, `${dc.fgDel}${Ansi.BOLD}`, `${dbg.bgDel}${pwd.old}`, dbg.bgDel);
 			emitRow(adds[0]!.l.newNum, "+", dbg.bgGutterAdd, `${dc.fgAdd}${Ansi.BOLD}`, `${dbg.bgAdd}${pwd.new}`, dbg.bgAdd);
 			continue;

package/src/word-diff.ts

@@ -2,6 +2,7 @@
 
 import * as Diff from "diff";
 import * as Ansi from "./ansi/index.js";
+import type { DiffBg } from "./ansi/index.js";
 
 // ---------------------------------------------------------------------------
 // Word diff analysis
@@ -107,13 +108,17 @@ export function injectBg(
 }
 
 /** Simple word diff (no syntax hl) — fallback when Shiki isn't available. */
-export function plainWordDiff(oldText: string, newText: string): { old: string; new: string } {
+export function plainWordDiff(
+	oldText: string,
+	newText: string,
+	dbg: DiffBg,
+): { old: string; new: string } {
 	const parts = Diff.diffWords(oldText, newText);
 	let o = "",
 		n = "";
 	for (const p of parts) {
-		if (p.removed) o += `${Ansi.BG_DEL_W}${p.value}${Ansi.RST}${Ansi.BG_DEL}`;
-		else if (p.added) n += `${Ansi.BG_ADD_W}${p.value}${Ansi.RST}${Ansi.BG_ADD}`;
+		if (p.removed) o += `${dbg.bgDelW}${p.value}${Ansi.RST}${dbg.bgDel}`;
+		else if (p.added) n += `${dbg.bgAddW}${p.value}${Ansi.RST}${dbg.bgAdd}`;
 		else {
 			o += p.value;
 			n += p.value;