limina 0.0.6 → 0.1.2

package/chunks/dep-mnWOqiGN.js

@@ -0,0 +1,244 @@
+//#region src/flow/render-model.ts
+const ANSI_RESET = "\x1B[0m";
+const ANSI_GREEN = "\x1B[32m";
+const ANSI_RED = "\x1B[31m";
+const ANSI_YELLOW = "\x1B[33m";
+const DEFAULT_TERMINAL_COLUMNS$1 = 80;
+const TERMINAL_FRAME_MARGIN_LINES = 1;
+const TERMINAL_FRAME_CONTEXT_LINES = 6;
+const OMITTED_LINES_MARKER = "│  ...";
+const ANSI_ESCAPE = String.fromCodePoint(27);
+const ANSI_PATTERN = new RegExp(String.raw`${ANSI_ESCAPE}\[[\d:;<=>?]*[\u0020-\u002F]*[\u0040-\u007E]`, "gu");
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const SPINNER_INTERVAL_MS = 80;
+const FLOW_SYMBOL_BY_STATUS = {
+	fail: "✕",
+	info: "│",
+	pass: "◆",
+	planned: "◇",
+	skip: "◇",
+	start: "◇",
+	warn: "▲"
+};
+function colorInteractiveSymbol(status, symbol) {
+	if (status === "pass") return `${ANSI_GREEN}${symbol}${ANSI_RESET}`;
+	if (status === "fail") return `${ANSI_RED}${symbol}${ANSI_RESET}`;
+	if (status === "warn") return `${ANSI_YELLOW}${symbol}${ANSI_RESET}`;
+	return symbol;
+}
+function formatElapsedTime(milliseconds) {
+	if (milliseconds < 1e3) return `${Math.round(milliseconds)}ms`;
+	return `${(milliseconds / 1e3).toFixed(2)}s`;
+}
+function formatMessageWithElapsed(message, elapsedTimeMs) {
+	return typeof elapsedTimeMs === "number" ? `${message} (${formatElapsedTime(elapsedTimeMs)})` : message;
+}
+function indentMessage(message, depth) {
+	if (depth <= 0) return message;
+	return `${"  ".repeat(depth)}${message}`;
+}
+function formatInteractiveLine(status, message, depth, spinnerFrameIndex) {
+	const renderedMessage = indentMessage(message, depth);
+	return `${colorInteractiveSymbol(status, status === "start" ? SPINNER_FRAMES[spinnerFrameIndex % SPINNER_FRAMES.length] : FLOW_SYMBOL_BY_STATUS[status])}    ${renderedMessage}`;
+}
+function toTreeFlowStatus(status) {
+	switch (status) {
+		case "failed": return "fail";
+		case "passed": return "pass";
+		case "planned": return "planned";
+		case "running": return "start";
+		case "skipped": return "skip";
+	}
+	throw new Error(`Unsupported flow tree node status: ${status}`);
+}
+function isTreeNodeTerminal(node) {
+	return node.status === "failed" || node.status === "passed" || node.status === "skipped";
+}
+function areTreeNodeDescendantsTerminal(node) {
+	return node.children.every((child) => isTreeNodeTerminal(child) && areTreeNodeDescendantsTerminal(child));
+}
+function renderTreeNodeLine(node, spinnerFrameIndex) {
+	const elapsedTimeMs = isTreeNodeTerminal(node) && areTreeNodeDescendantsTerminal(node) ? node.elapsedTimeMs : void 0;
+	return formatInteractiveLine(toTreeFlowStatus(node.status), formatMessageWithElapsed(node.message, elapsedTimeMs), node.depth, spinnerFrameIndex);
+}
+function renderTreeNodeLines(node, spinnerFrameIndex) {
+	return [renderTreeNodeLine(node, spinnerFrameIndex), ...node.children.flatMap((child) => renderTreeNodeLines(child, spinnerFrameIndex))];
+}
+function renderCompactTreeNodeLines(node, spinnerFrameIndex) {
+	return [renderTreeNodeLine(node, spinnerFrameIndex), ...node.children.map((child) => renderTreeNodeLine(child, spinnerFrameIndex))];
+}
+function renderSnapshotLines(snapshot, spinnerFrameIndex) {
+	const lines = snapshot.entries.flatMap((entry) => {
+		if (entry.kind === "line") return [entry.line];
+		if (entry.kind === "flow-line") return [formatInteractiveLine(entry.status, formatMessageWithElapsed(entry.message, entry.elapsedTimeMs), entry.depth, spinnerFrameIndex)];
+		return snapshot.treeRoots.flatMap((root) => renderTreeNodeLines(root, spinnerFrameIndex));
+	});
+	return snapshot.outroMessage ? [...lines, `└  ${snapshot.outroMessage}`] : lines;
+}
+function renderCompactSnapshotLines(snapshot, spinnerFrameIndex) {
+	const flowLineDepths = snapshot.entries.filter((entry) => entry.kind === "flow-line").map((entry) => entry.depth);
+	const maxCompactFlowLineDepth = flowLineDepths.length > 0 ? Math.min(...flowLineDepths) + 1 : Number.POSITIVE_INFINITY;
+	const lines = snapshot.entries.flatMap((entry) => {
+		if (entry.kind === "line") return [entry.line];
+		if (entry.kind === "flow-line") {
+			if (entry.depth > maxCompactFlowLineDepth) return [];
+			return [formatInteractiveLine(entry.status, formatMessageWithElapsed(entry.message, entry.elapsedTimeMs), entry.depth, spinnerFrameIndex)];
+		}
+		return snapshot.treeRoots.flatMap((root) => renderCompactTreeNodeLines(root, spinnerFrameIndex));
+	});
+	return snapshot.outroMessage ? [...lines, `└  ${snapshot.outroMessage}`] : lines;
+}
+function stripControlSequences(text) {
+	return text.replaceAll(ANSI_PATTERN, "").replaceAll("\r", "");
+}
+function countRenderedTerminalRows(line, columns) {
+	const text = stripControlSequences(line);
+	let column = 0;
+	let rows = 1;
+	for (const char of text) {
+		if (char === "\n") {
+			rows += 1;
+			column = 0;
+			continue;
+		}
+		column += 1;
+		if (column >= columns) {
+			rows += 1;
+			column = 0;
+		}
+	}
+	return rows;
+}
+function countRenderedRows(lines, dimensions) {
+	const columns = Math.max(1, dimensions.columns ?? DEFAULT_TERMINAL_COLUMNS$1);
+	return lines.reduce((sum, line) => sum + countRenderedTerminalRows(line, columns), 0);
+}
+function fitsRenderedLines(lines, dimensions, options = {}) {
+	if (dimensions.rows === void 0) return true;
+	const contextLines = options.reserveContext && dimensions.rows > TERMINAL_FRAME_CONTEXT_LINES * 2 ? TERMINAL_FRAME_CONTEXT_LINES : 0;
+	const lineLimit = Math.max(1, dimensions.rows - TERMINAL_FRAME_MARGIN_LINES - contextLines);
+	return countRenderedRows(lines, dimensions) <= lineLimit;
+}
+function fitRenderedLinesToTerminal(lines, dimensions, options = {}) {
+	if (fitsRenderedLines(lines, dimensions) && !options.omittedLines) return lines;
+	if (dimensions.rows === void 0) return options.omittedLines ? addOmittedLinesMarker(lines) : lines;
+	const lineLimit = Math.max(1, dimensions.rows - TERMINAL_FRAME_MARGIN_LINES);
+	const columns = Math.max(1, dimensions.columns ?? DEFAULT_TERMINAL_COLUMNS$1);
+	const lastLine = lines.at(-1);
+	const shouldPreserveOutro = lastLine?.startsWith("└  ") ?? false;
+	const bodyLineCount = lines.length - (shouldPreserveOutro ? 1 : 0);
+	const bodyLines = lines.slice(0, bodyLineCount);
+	const ellipsisRows = countRenderedTerminalRows(OMITTED_LINES_MARKER, columns);
+	const reservedRows = shouldPreserveOutro && lastLine ? countRenderedTerminalRows(lastLine, columns) : 0;
+	const availableBodyRows = Math.max(0, lineLimit - reservedRows);
+	const bodyRows = countRenderedRows(bodyLines, { columns });
+	const shouldShowOmissionMarker = (options.omittedLines === true || bodyRows > availableBodyRows) && availableBodyRows >= ellipsisRows;
+	const fittedLines = [];
+	let remainingRows = availableBodyRows;
+	if (shouldShowOmissionMarker) remainingRows -= ellipsisRows;
+	for (let index = 0; index < bodyLineCount && remainingRows > 0; index++) {
+		const line = lines[index];
+		const rowCount = countRenderedTerminalRows(line, columns);
+		if (rowCount > remainingRows) break;
+		fittedLines.push(line);
+		remainingRows -= rowCount;
+	}
+	if (shouldShowOmissionMarker) fittedLines.push(OMITTED_LINES_MARKER);
+	if (shouldPreserveOutro && lastLine && reservedRows <= lineLimit) fittedLines.push(lastLine);
+	if (fittedLines.length > 0) return fittedLines;
+	return lines.slice(0, 1);
+}
+function addOmittedLinesMarker(lines) {
+	if (lines.includes(OMITTED_LINES_MARKER)) return lines;
+	const lastLine = lines.at(-1);
+	if (lastLine?.startsWith("└  ")) return [
+		...lines.slice(0, -1),
+		OMITTED_LINES_MARKER,
+		lastLine
+	];
+	return [...lines, OMITTED_LINES_MARKER];
+}
+function renderSnapshotLinesForTerminal(snapshot, spinnerFrameIndex, dimensions) {
+	const shouldPreferCompact = snapshot.compactMode === "check-flow" && snapshot.outroMessage !== void 0;
+	const fullLines = renderSnapshotLines(snapshot, spinnerFrameIndex);
+	if (!shouldPreferCompact && fitsRenderedLines(fullLines, dimensions, { reserveContext: true })) return fullLines;
+	const compactLines = renderCompactSnapshotLines(snapshot, spinnerFrameIndex);
+	return fitRenderedLinesToTerminal(compactLines, dimensions, { omittedLines: compactLines.length < fullLines.length });
+}
+function hasRunningSnapshotWork(snapshot) {
+	const hasRunningTreeNode = (node) => node.status === "running" || node.children.some(hasRunningTreeNode);
+	return snapshot.entries.some((entry) => entry.kind === "flow-line" && entry.status === "start") || snapshot.treeRoots.some(hasRunningTreeNode);
+}
+function toWritableText(chunk) {
+	if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString();
+	return chunk;
+}
+
+//#endregion
+//#region src/flow/terminal-frame.ts
+const DEFAULT_TERMINAL_COLUMNS = 80;
+var TerminalFrameTracker = class {
+	#column = 0;
+	#lineCount = 0;
+	#getColumns;
+	constructor(getColumns) {
+		this.#getColumns = getColumns;
+	}
+	get lineCount() {
+		return this.#lineCount;
+	}
+	record(chunk) {
+		const text = stripControlSequences(toWritableText(chunk));
+		const columns = Math.max(1, this.#getColumns());
+		for (const char of text) {
+			if (char === "\n") {
+				this.#lineCount += 1;
+				this.#column = 0;
+				continue;
+			}
+			this.#column += 1;
+			if (this.#column >= columns) {
+				this.#lineCount += 1;
+				this.#column = 0;
+			}
+		}
+	}
+	reset() {
+		this.#lineCount = 0;
+		this.#column = 0;
+	}
+	setLineCount(lineCount) {
+		this.#lineCount = Math.max(0, lineCount);
+		this.#column = 0;
+	}
+};
+function patchWriteStream(stream, onWrite) {
+	if (typeof stream?.write !== "function") return;
+	const originalWrite = stream.write;
+	const patchedWrite = (...args) => {
+		onWrite(args[0]);
+		return writeWithFlowArgs(originalWrite, args);
+	};
+	stream.write = patchedWrite;
+	return () => {
+		stream.write = originalWrite;
+	};
+}
+function writeWithFlowArgs(write, args) {
+	if (typeof args[1] === "string") return write(args[0], args[1], args[2]);
+	return write(args[0], args[1]);
+}
+
+//#endregion
+export { SPINNER_FRAMES as a, formatMessageWithElapsed as c, toTreeFlowStatus as d, toWritableText as f, writeWithFlowArgs as i, hasRunningSnapshotWork as l, TerminalFrameTracker as n, SPINNER_INTERVAL_MS as o, patchWriteStream as r, formatInteractiveLine as s, DEFAULT_TERMINAL_COLUMNS as t, renderSnapshotLinesForTerminal as u };