@pi-archimedes/diff 0.3.1 → 0.4.0

package/package.json

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

package/src/ansi.ts

@@ -103,7 +103,7 @@ export function isLowContrastShikiFg(params: string): boolean {
 	if (!params.startsWith("38;2;")) return false;
 	const parts = params.split(";").map(Number);
 	if (parts.length !== 5 || parts.some((n) => !Number.isFinite(n))) return false;
-	const [, , r, g, b] = parts;
+	const [, , r, g, b] = parts as [number, number, number, number, number];
 	const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
 	return luminance < 72;
 }
@@ -156,7 +156,7 @@ export function summarize(a: number, d: number): string {
 function parseAnsiRgb(ansi: string): { r: number; g: number; b: number } | null {
 	const esc = "\u001b";
 	const m = ansi.match(new RegExp(`${esc}\\[(?:38|48);2;(\\d+);(\\d+);(\\d+)m`));
-	return m ? { r: +m[1], g: +m[2], b: +m[3] } : null;
+	return m ? { r: +m[1]!, g: +m[2]!, b: +m[3]! } : null;
 }
 
 /** Mix an accent color into a base color at the given intensity (0.0–1.0). */
@@ -243,11 +243,31 @@ export function themeCacheKey(theme?: any): string {
 	return parts.join("|");
 }
 
-let _didAutoDerive = false;
+let _lastThemeKey: string | undefined;
+
+/** Reset auto-derived colors — call when theme changes. */
+export function resetDiffColors(): void {
+	_lastThemeKey = undefined;
+	// Restore hardcoded fallbacks
+	BG_ADD = "\x1b[48;2;22;38;32m";
+	BG_DEL = "\x1b[48;2;45;25;25m";
+	BG_ADD_W = "\x1b[48;2;35;75;50m";
+	BG_DEL_W = "\x1b[48;2;80;35;35m";
+	BG_GUTTER_ADD = "\x1b[48;2;18;32;26m";
+	BG_GUTTER_DEL = "\x1b[48;2;38;22;22m";
+	BG_EMPTY = "\x1b[48;2;18;18;18m";
+	BG_BASE = BG_DEFAULT;
+	RST = "\x1b[0m";
+	DIVIDER = `${FG_RULE}│${RST}`;
+}
+
 export function resolveDiffColors(theme?: any): DiffColors {
-	if (!_didAutoDerive && theme?.getFgAnsi) {
+	const themeKey = themeCacheKey(theme);
+
+	// Re-derive when theme changes (different key) or first call
+	if (themeKey !== _lastThemeKey && theme?.getFgAnsi) {
 		autoDeriveBgFromTheme(theme);
-		_didAutoDerive = true;
+		_lastThemeKey = themeKey;
 	}
 	if (!theme?.getFgAnsi) return DEFAULT_DIFF_COLORS;
 	try {

package/src/core/diff.ts

@@ -22,16 +22,17 @@ export function parseDiff(oldContent: string, newContent: string, ctx = 3): Pars
 
 	for (let hi = 0; hi < patch.hunks.length; hi++) {
 		if (hi > 0) {
-			const prev = patch.hunks[hi - 1];
-			const gap = patch.hunks[hi].oldStart - (prev.oldStart + prev.oldLines);
+			const prev = patch.hunks[hi - 1]!;
+			const curr = patch.hunks[hi]!;
+			const gap = curr.oldStart - (prev.oldStart + prev.oldLines);
 			lines.push({ type: "sep", oldNum: null, newNum: gap > 0 ? gap : null, content: "" });
 		}
-		const h = patch.hunks[hi];
+		const h = patch.hunks[hi]!;
 		let oL = h.oldStart;
 		let nL = h.newStart;
 		for (const raw of h.lines) {
 			if (raw === "\") continue;
-			const ch = raw[0];
+			const ch = raw[0]!;
 			const text = raw.slice(1);
 			if (ch === "+") {
 				lines.push({ type: "add", oldNum: null, newNum: nL++, content: text });

package/src/index.ts

@@ -13,7 +13,7 @@ import * as Ansi from "./ansi.js";
 import { resolveDiffColors, themeCacheKey, DEFAULT_DIFF_COLORS } from "./ansi.js";
 import { setConfigGetter as setShikiConfig } from "./shiki.js";
 import { hlBlock, lang } from "./shiki.js";
-import { renderSplit } from "./render.js";
+import { renderSplit, MAX_PREVIEW_LINES, MAX_RENDER_LINES } from "./render.js";
 import { setConfigGetter as setRenderConfig } from "./render.js";
 
 // ---------------------------------------------------------------------------
@@ -35,13 +35,6 @@ const DEFAULT_DIFF_CONFIG: DiffConfig = {
 let _readConfig: () => DiffConfig = () => DEFAULT_DIFF_CONFIG;
 function getConfig(): DiffConfig { return _readConfig(); }
 
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const MAX_PREVIEW_LINES = 60;
-const MAX_RENDER_LINES = 150;
-
 // ---------------------------------------------------------------------------
 // Settings
 // ---------------------------------------------------------------------------
@@ -296,7 +289,7 @@ export function registerDiffTools(
 					try {
 						if (fp && existsSync(fp)) {
 							const f = readFileSync(fp, "utf-8");
-							const idx = f.indexOf(operations[0].newText);
+							const idx = f.indexOf(operations[0]!.newText);
 							if (idx >= 0) editLine = f.slice(0, idx).split("\n").length;
 						}
 					} catch { editLine = 0; }
@@ -332,7 +325,7 @@ export function registerDiffTools(
 					const dc = resolveDiffColors(theme);
 
 					if (operations.length === 1) {
-						const diff = parseDiff(operations[0].oldText, operations[0].newText);
+						const diff = parseDiff(operations[0]!.oldText, operations[0]!.newText);
 						renderSplit(diff, lg, MAX_PREVIEW_LINES, dc)
 							.then((rendered) => {
 								if (ctx.state._pk !== pk) return;

package/src/render.ts

@@ -12,8 +12,8 @@ import type { DiffLine, ParsedDiff } from "./core/diff.js";
 // Constants
 // ---------------------------------------------------------------------------
 
-const MAX_PREVIEW_LINES = 60;
-const MAX_RENDER_LINES = 150;
+export const MAX_PREVIEW_LINES = 60;
+export const MAX_RENDER_LINES = 150;
 const MAX_HL_CHARS = 80_000;
 const WORD_DIFF_MIN_SIM = 0.15;
 const SPLIT_MAX_WRAP_RATIO = 0.2;
@@ -187,7 +187,7 @@ export async function renderUnified(
 	}
 
 	while (idx < vis.length) {
-		const l = vis[idx];
+		const l = vis[idx]!;
 
 		if (l.type === "sep") {
 			const gap = l.newNum;
@@ -208,30 +208,30 @@ export async function renderUnified(
 		}
 
 		const dels: Array<{ l: DiffLine; hl: string }> = [];
-		while (idx < vis.length && vis[idx].type === "del") {
-			dels.push({ l: vis[idx], hl: oldHL[oI] ?? vis[idx].content });
+		while (idx < vis.length && vis[idx]!.type === "del") {
+			dels.push({ l: vis[idx]!, hl: oldHL[oI] ?? vis[idx]!.content });
 			oI++; idx++;
 		}
 		const adds: Array<{ l: DiffLine; hl: string }> = [];
-		while (idx < vis.length && vis[idx].type === "add") {
-			adds.push({ l: vis[idx], hl: newHL[nI] ?? vis[idx].content });
+		while (idx < vis.length && vis[idx]!.type === "add") {
+			adds.push({ l: vis[idx]!, hl: newHL[nI] ?? vis[idx]!.content });
 			nI++; idx++;
 		}
 
 		const isPaired = dels.length === 1 && adds.length === 1;
-		const wd = isPaired ? wordDiffAnalysis(dels[0].l.content, adds[0].l.content) : null;
+		const wd = isPaired ? wordDiffAnalysis(dels[0]!.l.content, adds[0]!.l.content) : null;
 
 		if (isPaired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && canHL) {
-			const delBody = injectBg(dels[0].hl, wd.oldRanges, Ansi.BG_DEL, Ansi.BG_DEL_W);
-			const addBody = injectBg(adds[0].hl, wd.newRanges, Ansi.BG_ADD, Ansi.BG_ADD_W);
-			emitRow(dels[0].l.oldNum, "-", Ansi.BG_GUTTER_DEL, `${dc.fgDel}${Ansi.BOLD}`, delBody, Ansi.BG_DEL);
-			emitRow(adds[0].l.newNum, "+", Ansi.BG_GUTTER_ADD, `${dc.fgAdd}${Ansi.BOLD}`, addBody, Ansi.BG_ADD);
+			const delBody = injectBg(dels[0]!.hl, wd.oldRanges, Ansi.BG_DEL, Ansi.BG_DEL_W);
+			const addBody = injectBg(adds[0]!.hl, wd.newRanges, Ansi.BG_ADD, Ansi.BG_ADD_W);
+			emitRow(dels[0]!.l.oldNum, "-", Ansi.BG_GUTTER_DEL, `${dc.fgDel}${Ansi.BOLD}`, delBody, Ansi.BG_DEL);
+			emitRow(adds[0]!.l.newNum, "+", Ansi.BG_GUTTER_ADD, `${dc.fgAdd}${Ansi.BOLD}`, addBody, Ansi.BG_ADD);
 			continue;
 		}
 		if (isPaired && wd && wd.similarity >= WORD_DIFF_MIN_SIM && !canHL) {
-			const pwd = plainWordDiff(dels[0].l.content, adds[0].l.content);
-			emitRow(dels[0].l.oldNum, "-", Ansi.BG_GUTTER_DEL, `${dc.fgDel}${Ansi.BOLD}`, `${Ansi.BG_DEL}${pwd.old}`, Ansi.BG_DEL);
-			emitRow(adds[0].l.newNum, "+", Ansi.BG_GUTTER_ADD, `${dc.fgAdd}${Ansi.BOLD}`, `${Ansi.BG_ADD}${pwd.new}`, Ansi.BG_ADD);
+			const pwd = plainWordDiff(dels[0]!.l.content, adds[0]!.l.content);
+			emitRow(dels[0]!.l.oldNum, "-", Ansi.BG_GUTTER_DEL, `${dc.fgDel}${Ansi.BOLD}`, `${Ansi.BG_DEL}${pwd.old}`, Ansi.BG_DEL);
+			emitRow(adds[0]!.l.newNum, "+", Ansi.BG_GUTTER_ADD, `${dc.fgAdd}${Ansi.BOLD}`, `${Ansi.BG_ADD}${pwd.new}`, Ansi.BG_ADD);
 			continue;
 		}
 
@@ -270,11 +270,11 @@ export async function renderSplit(
 	const rows: Row[] = [];
 	let i = 0;
 	while (i < diff.lines.length) {
-		const l = diff.lines[i];
+		const l = diff.lines[i]!;
 		if (l.type === "sep" || l.type === "ctx") { rows.push({ left: l, right: l }); i++; continue; }
 		const dels: DiffLine[] = [], adds: DiffLine[] = [];
-		while (i < diff.lines.length && diff.lines[i].type === "del") { dels.push(diff.lines[i]); i++; }
-		while (i < diff.lines.length && diff.lines[i].type === "add") { adds.push(diff.lines[i]); i++; }
+		while (i < diff.lines.length && diff.lines[i]!.type === "del") { dels.push(diff.lines[i]!); i++; }
+		while (i < diff.lines.length && diff.lines[i]!.type === "add") { adds.push(diff.lines[i]!); i++; }
 		const n = Math.max(dels.length, adds.length);
 		for (let j = 0; j < n; j++) rows.push({ left: dels[j] ?? null, right: adds[j] ?? null });
 	}

package/src/shiki.ts

@@ -52,12 +52,13 @@ async function ensureShiki(): Promise<void> {
 const _cache = new Map<string, string[]>();
 
 function _touch(k: string, v: string[]): string[] {
+	// True LRU: delete and re-insert to move to end (most recently used)
 	_cache.delete(k);
 	_cache.set(k, v);
 	while (_cache.size > CACHE_LIMIT) {
-		const first = _cache.keys().next().value;
-		if (first === undefined) break;
-		_cache.delete(first);
+		const oldest = _cache.keys().next().value;
+		if (oldest === undefined) break;
+		_cache.delete(oldest);
 	}
 	return v;
 }
@@ -71,7 +72,7 @@ export async function hlBlock(code: string, language: BundledLanguage | undefine
 	const theme = _getConfig().diffTheme;
 	const k = `${theme}\0${language}\0${code}`;
 	const hit = _cache.get(k);
-	if (hit) return _touch(k, hit);
+	if (hit) return _touch(k, hit); // Promote to most-recently-used
 
 	try {
 		const ansi = normalizeShikiContrast(await codeToANSI(code, language, theme as BundledTheme));

package/src/word-diff.ts

@@ -52,6 +52,8 @@ export function wordDiffAnalysis(
  * Inject diff background into Shiki ANSI output.
  * `baseBg` on unchanged spans, `hlBg` on changed character ranges.
  * Re-injects bg after any full reset (\x1b[0m).
+ *
+ * Handles unsorted and overlapping ranges by checking all ranges per position.
  */
 export function injectBg(
 	ansiLine: string,
@@ -61,6 +63,17 @@ export function injectBg(
 ): string {
 	if (!ranges.length) return baseBg + ansiLine + Ansi.RST;
 
+	// Sort ranges and merge overlaps for efficient lookup
+	const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+	const merged: Array<[number, number]> = [];
+	for (const [start, end] of sorted) {
+		if (merged.length > 0 && start <= merged[merged.length - 1]![1]) {
+			merged[merged.length - 1]![1] = Math.max(merged[merged.length - 1]![1], end);
+		} else {
+			merged.push([start, end]);
+		}
+	}
+
 	let out = baseBg;
 	let vis = 0;
 	let inHL = false;
@@ -68,7 +81,7 @@ export function injectBg(
 	let i = 0;
 
 	while (i < ansiLine.length) {
-		if (ansiLine[i] === "\x1b") {
+		if (ansiLine[i]! === "\x1b") {
 			const m = ansiLine.indexOf("m", i);
 			if (m !== -1) {
 				const seq = ansiLine.slice(i, m + 1);
@@ -78,13 +91,15 @@ export function injectBg(
 				continue;
 			}
 		}
-		while (ri < ranges.length && vis >= ranges[ri][1]) ri++;
-		const want = ri < ranges.length && vis >= ranges[ri][0] && vis < ranges[ri][1];
+		// Advance range index past completed ranges
+		while (ri < merged.length && vis >= merged[ri]![1]) ri++;
+		// Check if current position falls within the next range
+		const want = ri < merged.length && vis >= merged[ri]![0] && vis < merged[ri]![1];
 		if (want !== inHL) {
 			inHL = want;
 			out += inHL ? hlBg : baseBg;
 		}
-		out += ansiLine[i];
+		out += ansiLine[i]!;
 		vis++;
 		i++;
 	}