limina 0.1.1 → 0.1.2

package/flow-renderer-process.js

@@ -1,53 +1,46 @@
-import { a as hasRunningSnapshotWork, c as toWritableText, n as SPINNER_INTERVAL_MS, o as renderSnapshotLines, t as SPINNER_FRAMES } from "./chunks/dep-CuMHuWBQ.js";
+import { a as SPINNER_FRAMES, l as hasRunningSnapshotWork, n as TerminalFrameTracker, o as SPINNER_INTERVAL_MS, t as DEFAULT_TERMINAL_COLUMNS, u as renderSnapshotLinesForTerminal } from "./chunks/dep-mnWOqiGN.js";
 
 //#region src/flow/renderer-process.ts
-const DEFAULT_TERMINAL_COLUMNS = 80;
-const ANSI_ESCAPE = String.fromCodePoint(27);
-const ANSI_PATTERN = new RegExp(String.raw`${ANSI_ESCAPE}\[[\d:;<=>?]*[\u0020-\u002F]*[\u0040-\u007E]`, "gu");
 let snapshot = {
 	entries: [],
 	treeRoots: []
 };
-let terminalColumn = 0;
-let terminalLineCount = 0;
+const terminalFrame = new TerminalFrameTracker(getTerminalColumns);
+const FLOW_RENDERER_TEST_COLUMNS_ENV = "LIMINA_FLOW_RENDERER_TEST_COLUMNS";
 let spinnerFrameIndex = 0;
 let spinnerTimer;
 let closed = false;
 function send(message) {
 	if (typeof process.send === "function") process.send(message);
 }
-function stripControlSequences(text) {
-	return text.replaceAll(ANSI_PATTERN, "").replaceAll("\r", "");
+function readPositiveInteger(value) {
+	if (value === void 0) return;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
 }
-function recordTerminalWrite(chunk) {
-	const text = stripControlSequences(toWritableText(chunk));
-	const columns = Math.max(1, process.stdout.columns ?? DEFAULT_TERMINAL_COLUMNS);
-	for (const char of text) {
-		if (char === "\n") {
-			terminalLineCount += 1;
-			terminalColumn = 0;
-			continue;
-		}
-		terminalColumn += 1;
-		if (terminalColumn >= columns) {
-			terminalLineCount += 1;
-			terminalColumn = 0;
-		}
-	}
+function getTerminalColumns() {
+	return Math.max(1, readPositiveInteger(process.env[FLOW_RENDERER_TEST_COLUMNS_ENV]) ?? process.stdout.columns ?? snapshot.terminalDimensions?.columns ?? DEFAULT_TERMINAL_COLUMNS);
+}
+function getTerminalRows() {
+	return readPositiveInteger(process.env.LIMINA_FLOW_RENDERER_TEST_ROWS) ?? process.stdout.rows;
 }
 function writeTracked(message, stream) {
-	recordTerminalWrite(message);
+	terminalFrame.record(message);
 	stream.write(message);
 }
 function clearRenderedFrame() {
-	if (terminalLineCount <= 0) return;
-	process.stdout.write(`\r\u001B[${terminalLineCount}A\u001B[J`);
-	terminalLineCount = 0;
-	terminalColumn = 0;
+	if (terminalFrame.lineCount <= 0) return;
+	process.stdout.write(`\r\u001B[${terminalFrame.lineCount}A\u001B[J`);
+	terminalFrame.reset();
 }
 function render() {
 	clearRenderedFrame();
-	for (const line of renderSnapshotLines(snapshot, spinnerFrameIndex)) writeTracked(`${line}\n`, process.stdout);
+	const dimensions = {
+		columns: getTerminalColumns(),
+		rows: snapshot.terminalDimensions?.rows ?? getTerminalRows()
+	};
+	const renderedLines = renderSnapshotLinesForTerminal(snapshot, spinnerFrameIndex, dimensions);
+	for (const line of renderedLines) writeTracked(`${line}\n`, process.stdout);
 }
 function syncSpinnerTimer() {
 	if (closed || !hasRunningSnapshotWork(snapshot)) {
@@ -66,8 +59,7 @@ function syncSpinnerTimer() {
 function writeOutput(message) {
 	clearRenderedFrame();
 	writeTracked(message.output.text, message.output.stream === "stderr" ? process.stderr : process.stdout);
-	terminalLineCount = 0;
-	terminalColumn = 0;
+	terminalFrame.reset();
 	render();
 }
 process.on("message", (rawMessage) => {

package/index.js

@@ -1,3 +1,3 @@
-import { t as defineConfig } from "./chunks/dep-C5gcXDHp.js";
+import { t as defineConfig } from "./chunks/dep-DJz9JBTi.js";
 
 export { defineConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limina",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "license": "MIT",
   "author": "Senao Xi",

package/schemas/tsconfig-schema.json

@@ -47,6 +47,29 @@
             }
           }
         },
+        "outputs": {
+          "type": "object",
+          "description": "User-facing artifact output build options for this ordinary source tsconfig.",
+          "additionalProperties": false,
+          "properties": {
+            "target": {
+              "$ref": "#/definitions/nonEmptyString",
+              "description": "TypeScript target for generated artifact output builds."
+            },
+            "rootDir": {
+              "$ref": "#/definitions/nonEmptyString",
+              "description": "Artifact build rootDir, relative to this tsconfig."
+            },
+            "outDir": {
+              "$ref": "#/definitions/nonEmptyString",
+              "description": "Artifact build outDir, relative to this tsconfig."
+            },
+            "tsBuildInfoFile": {
+              "$ref": "#/definitions/nonEmptyString",
+              "description": "Artifact build tsBuildInfoFile, relative to this tsconfig."
+            }
+          }
+        },
         "graphRules": {
           "type": "array",
           "description": "Graph rule labels from limina.config.mjs#graph.rules that apply to this declaration leaf.",

package/chunks/dep-CuMHuWBQ.js

@@ -1,87 +0,0 @@
-//#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 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 renderTreeNodeLines(node, spinnerFrameIndex) {
-	const elapsedTimeMs = isTreeNodeTerminal(node) && areTreeNodeDescendantsTerminal(node) ? node.elapsedTimeMs : void 0;
-	return [formatInteractiveLine(toTreeFlowStatus(node.status), formatMessageWithElapsed(node.message, elapsedTimeMs), node.depth, spinnerFrameIndex), ...node.children.flatMap((child) => renderTreeNodeLines(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 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 String(chunk);
-}
-
-//#endregion
-export { hasRunningSnapshotWork as a, toWritableText as c, formatMessageWithElapsed as i, SPINNER_INTERVAL_MS as n, renderSnapshotLines as o, formatInteractiveLine as r, toTreeFlowStatus as s, SPINNER_FRAMES as t };