pi-supernova 0.3.1 → 0.4.0

package/src/shared/decode.js

@@ -1,18 +1,25 @@
 const toStr = Object.prototype.toString;
 
 export const isString = (v) => toStr.call(v) === "[object String]";
+
 export const isObject = (v) => toStr.call(v) === "[object Object]";
+
 export const isFunction = (v) => toStr.call(v) === "[object Function]" || v instanceof Function;
+
 export const isNumber = (v) => toStr.call(v) === "[object Number]" && Number.isFinite(v);
 
 const MAX_DEPTH = 64;
+
 const MAX_TYPED_ARRAY = 4096;
 
 function plainFromBinary(value) {
   const bytes = value.byteLength;
+
   if (value instanceof ArrayBuffer) value = new Uint8Array(value);
   else if (value instanceof DataView) value = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+
   if (value.length > MAX_TYPED_ARRAY) return "[" + value.constructor.name + " " + bytes + " bytes]";
+
   return value instanceof BigInt64Array || value instanceof BigUint64Array
     ? Array.from(value, x => x.toString() + "n")
     : Array.from(value);
@@ -20,18 +27,25 @@ function plainFromBinary(value) {
 
 function plainFromMap(value, seen, depth) {
   const allStringKeys = [...value.keys()].every(isString);
+
   if (!allStringKeys) return [...value].map(([k, v]) => [toPlain(k, seen, depth + 1), toPlain(v, seen, depth + 1)]);
   const out = Object.create(null);
+
   for (const [k, v] of value) out[k] = toPlain(v, seen, depth + 1);
+
   return out;
 }
 
 function plainFromCollection(value, seen, depth) {
   if (Array.isArray(value)) return value.map((x) => toPlain(x, seen, depth + 1));
+
   if (value instanceof Set) return [...value].map((x) => toPlain(x, seen, depth + 1));
+
   if (value instanceof Map) return plainFromMap(value, seen, depth);
   const out = Object.create(null);
+
   for (const k of Object.keys(value)) out[k] = toPlain(value[k], seen, depth + 1);
+
   return out;
 }
 
@@ -39,23 +53,38 @@ function plainFromCollection(value, seen, depth) {
 export function toPlain(value, seen = new Set(), depth = 0) {
   if (value === null || value === undefined) return value;
   const tag = toStr.call(value);
+
   if (tag === "[object String]" || tag === "[object Number]" || tag === "[object Boolean]") return value.valueOf();
+
   if (tag === "[object BigInt]") return value.toString() + "n";
+
   if (isFunction(value)) return "[Function" + (value.name ? " " + value.name : "") + "]";
+
   if (tag === "[object Symbol]") return value.toString();
+
   if (depth > MAX_DEPTH) return "[Depth]";
+
   if (seen.has(value)) return "[Circular]";
+
   if (value instanceof Date) return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+
   if (value instanceof RegExp) return value.toString();
+
   if (value instanceof Error) {
     const out = { name: value.name, message: value.message };
+
     if (value.cause !== undefined) out.cause = toPlain(value.cause, seen, depth + 1);
+
     return out;
   }
+
   if (value instanceof Promise) return "[Promise]";
+
   if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return plainFromBinary(value);
+
   if (isFunction(value.toJSON)) return toPlain(value.toJSON(), seen, depth + 1);
   seen.add(value);
+
   try {
     return plainFromCollection(value, seen, depth);
   } finally {

package/src/ui/omp-frame.js

@@ -21,7 +21,9 @@ const DEFAULT_BOX = {
 
 function boxOf(theme) {
 	const b = theme?.boxRound;
+
 	if (b && b.topLeft && b.horizontal && b.vertical) return b;
+
 	return DEFAULT_BOX;
 }
 
@@ -33,6 +35,7 @@ function borderKeyFor(state) {
 
 function borderPaint(theme, state, borderColor) {
 	const key = borderColor || borderKeyFor(state);
+
 	if (theme && isFunction(theme.fg)) {
 		try {
 			return (text) => theme.fg(key, text);
@@ -40,6 +43,7 @@ function borderPaint(theme, state, borderColor) {
 			/* fall through */
 		}
 	}
+
 	return (text) => text;
 }
 
@@ -51,6 +55,7 @@ function statusHeader(theme, { title, description, state, icon }) {
 	const prefix = prefixSpec ? (theme?.fg ? theme.fg(prefixSpec[0], prefixSpec[1]) : prefixSpec[1]) : "";
 	const titleText = theme?.fg ? theme.fg("accent", title) : title;
 	const descText = description ? (theme?.fg ? theme.fg("muted", description) : description) : "";
+
 	return descText ? `${prefix}${titleText}: ${descText}` : `${prefix}${titleText}`;
 }
 
@@ -59,6 +64,7 @@ function padLine(line, width, bgFn) {
 	const vis = measureWidth(line);
 	const pad = Math.max(0, w - vis);
 	const padded = line + " ".repeat(pad);
+
 	return bgFn ? bgFn(padded) : padded;
 }
 
@@ -71,6 +77,7 @@ function bgKeyFor(state) {
 function wrapBg(paint) {
 	return (text) => {
 		const out = paint(text);
+
 		return isString(out) ? out : text;
 	};
 }
@@ -78,18 +85,24 @@ function wrapBg(paint) {
 function bgFnForState(theme, state) {
 	if (!state || !theme) return undefined;
 	const key = bgKeyFor(state);
+
 	if (isFunction(theme.bg)) {
 		try {
 			if (!isString(theme.bg(key, "x"))) return undefined;
 		} catch {
 			return undefined;
 		}
+
 		return wrapBg((text) => theme.bg(key, text));
 	}
+
 	if (!isFunction(theme.getBgAnsi)) return undefined;
+
 	try {
 		const ansi = theme.getBgAnsi(key);
+
 		if (!ansi) return undefined;
+
 		return (text) => `${ansi}${text}\x1b[49m`;
 	} catch {
 		return undefined;
@@ -100,8 +113,10 @@ function frameBodyLines(sections, contentWidth, box, border, bgFn, w, paintBar)
 	const lines = [];
 	const normalized = sections.length > 0 ? sections : [{ lines: [] }];
 	const v = box.vertical;
+
 	for (const section of normalized) {
 		if (section.label) lines.push(paintBar(box.teeRight || "├", box.teeLeft || "┤", section.label));
+
 		for (const raw of section.lines || []) {
 			for (const piece of String(raw).split("\n")) {
 				const body = clampLine(piece, contentWidth);
@@ -110,19 +125,24 @@ function frameBodyLines(sections, contentWidth, box, border, bgFn, w, paintBar)
 			}
 		}
 	}
+
 	return lines;
 }
 
 function renderPortableFrame(theme, { header, sections = [], state = "pending", borderColor, width }) {
 	const w = Math.max(1, width | 0);
+
 	if (w < 8) {
 		const rawLines = [header];
+
 		for (const section of sections) {
 			if (section.label) rawLines.push(section.label);
 			rawLines.push(...(section.lines || []));
 		}
-		return rawLines.filter(Boolean).map((line) => clampLine(line, w));
+
+		return rawLines.flatMap((line) => line ? [clampLine(line, w)] : []);
 	}
+
 	const box = boxOf(theme);
 	const border = borderPaint(theme, state, borderColor);
 	const bgFn = bgFnForState(theme, state);
@@ -132,14 +152,18 @@ function renderPortableFrame(theme, { header, sections = [], state = "pending",
 	const paintBar = (leftChar, rightChar, label) => {
 		const left = `${leftChar}${cap}`;
 		const right = rightChar;
+
 		if (!label) {
 			const fill = Math.max(0, w - measureWidth(left) - measureWidth(right));
+
 			return padLine(`${border(left)}${border(h.repeat(fill))}${border(right)}`, w, bgFn);
 		}
+
 		const rawLabel = ` ${label} `;
 		const maxLabel = Math.max(0, w - measureWidth(left) - measureWidth(right));
 		const trimmed = clampLine(rawLabel, maxLabel);
 		const fill = Math.max(0, w - measureWidth(left) - measureWidth(trimmed) - measureWidth(right));
+
 		return padLine(`${border(left)}${trimmed}${border(h.repeat(fill))}${border(right)}`, w, bgFn);
 	};
 
@@ -148,6 +172,7 @@ function renderPortableFrame(theme, { header, sections = [], state = "pending",
 	lines.push(paintBar(box.topLeft, box.topRight, header));
 	lines.push(...frameBodyLines(sections, contentWidth, box, border, bgFn, w, paintBar));
 	lines.push(paintBar(box.bottomLeft, box.bottomRight, null));
+
 	return lines;
 }
 
@@ -155,16 +180,20 @@ function createPortableFramedComponent(theme, build) {
 	let cacheWidth;
 	let cacheKey;
 	let cacheLines;
+
 	return {
 		render(width) {
 			const opts = build(width);
+
 			const key = `${opts.state}|${opts.borderColor}|${opts.header}|${(opts.sections || [])
 				.map((s) => (s.lines || []).join("\n"))
 				.join("||")}`;
+
 			if (cacheLines && cacheWidth === width && cacheKey === key) return cacheLines;
 			cacheLines = renderPortableFrame(theme, opts);
 			cacheWidth = width;
 			cacheKey = key;
+
 			return cacheLines;
 		},
 		invalidate() {

package/src/ui/render-measure.js

@@ -2,24 +2,30 @@ import { stripVTControlCharacters } from "node:util";
 import stringWidth from "string-width";
 
 const ELLIPSIS = "…";
+
 const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 
 const widthCache = new Map();
+
 let cachedWidthChars = 0;
+
 const MAX_WIDTH_CACHE_CHARS = 512_000;
 
 export function measureWidth(text) {
   const raw = String(text ?? "");
   const cached = widthCache.get(raw);
+
   if (cached !== undefined) return cached;
   const normalized = raw.replace(/\t/g, "   ");
   // eslint-disable-next-line no-control-regex -- intentional ANSI SGR recognition
   const plain = normalized.replace(/\x1b\[(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?m/g, "");
+
   // ASCII and these single-column chrome glyphs need no Unicode segmentation.
   // Any other character/control/escape sequence uses the full oracle.
   const width = /^[\x20-\x7e\u2500-\u257f\u00b7\u00d7\u2026\u2713\u2717]*$/.test(plain)
     ? plain.length
     : stringWidth(normalized);
+
   // Cache immutable text only, never host/theme/result objects. Bound both
   // bookkeeping and retained text; unusually long lines bypass retention.
   if (raw.length <= 4096) {
@@ -28,32 +34,41 @@ export function measureWidth(text) {
       widthCache.delete(oldest);
       cachedWidthChars -= oldest.length;
     }
+
     widthCache.set(raw, width);
     cachedWidthChars += raw.length;
   }
+
   return width;
 }
 
 function takePrefix(text, width) {
   let end = 0;
   let columns = 0;
+
   for (const { segment, index } of segmenter.segment(text)) {
     const next = measureWidth(segment);
+
     if (columns + next > width) break;
     columns += next;
     end = index + segment.length;
   }
+
   return text.slice(0, end);
 }
 
 export function hardTruncate(text, maxWidth, ellipsis = ELLIPSIS) {
   const width = Math.max(0, Math.floor(maxWidth));
+
   if (!width) return "";
   const raw = String(text ?? "").replace(/\t/g, "   ");
+
   if (measureWidth(raw) <= width) return raw;
   const suffix = stripVTControlCharacters(String(ellipsis));
   const suffixWidth = measureWidth(suffix);
+
   if (suffixWidth >= width) return takePrefix(suffix, width);
+
   return takePrefix(stripVTControlCharacters(raw), width - suffixWidth) + suffix;
 }
 
@@ -65,27 +80,36 @@ export function clampLine(line, width) {
 export function wrapLine(line, width) {
   if (width <= 0) return [];
   const text = String(line).replace(/\t/g, "   ");
+
   if (measureWidth(text) <= width) return [text];
   const out = [];
   let current = "";
   let columns = 0;
+
   for (const { segment } of segmenter.segment(text)) {
     const size = measureWidth(segment);
+
     if (columns + size > width && current) { out.push(current); current = ""; columns = 0; }
+
     if (size > width) { out.push(ELLIPSIS); continue; }
+
     current += segment;
     columns += size;
   }
+
   if (current) out.push(current);
+
   return out;
 }
 
 export function fitPath(pathText, budget) {
   const width = Math.max(0, Math.floor(budget));
   const text = String(pathText ?? "").replace(/\\/g, "/");
+
   if (measureWidth(text) <= width) return text;
   const parts = text.split("/").filter(Boolean);
   const base = parts.at(-1) ?? text;
   const suffix = parts.length > 1 ? "…/" + base : base;
+
   return measureWidth(suffix) <= width ? suffix : hardTruncate(base, width);
 }