@effected/cli 0.9.0 → 0.11.0

package/internal/renderDoc.js

@@ -0,0 +1,319 @@
+import { Fmt, sanitize } from "../Fmt.js";
+import { countsTableOf, totalOf, visibleCountersOf } from "./counts.js";
+import { truncateSpans, widthOf, wrapSpans } from "./layout.js";
+
+//#region src/internal/renderDoc.ts
+const span = (text, token) => token === void 0 ? { text } : {
+	text,
+	token
+};
+const textOf = (line) => line.map((s) => s.text).join("");
+/** A link target as plain text: the URL, or `path:line:col` through `displayPath`; a column needs a line. */
+const targetText = (target, ctx) => {
+	if ("url" in target) return sanitize(target.url);
+	const path = sanitize(ctx.displayPath(target.file));
+	if (target.line === void 0) return path;
+	return target.col === void 0 ? `${path}:${target.line}` : `${path}:${target.line}:${target.col}`;
+};
+/**
+* Whether a link's target follows its label where the link cannot be followed: the link's own `suffix` when it set one,
+* otherwise only when the label is not already the target's display form.
+*/
+const showsSuffix = (suffix, label, target) => suffix ?? label !== target;
+/** Drop trailing spaces, and any span they empty, so a line never ends in padding. */
+const trimLine = (line) => {
+	const out = [...line];
+	while (out.length > 0) {
+		const last = out[out.length - 1];
+		if (last.hold === true) break;
+		const trimmed = last.text.trimEnd();
+		if (trimmed === "") {
+			out.pop();
+			continue;
+		}
+		if (trimmed !== last.text) out[out.length - 1] = {
+			...last,
+			text: trimmed
+		};
+		break;
+	}
+	return out;
+};
+const oneLine = (spans) => spans.map((s) => ({
+	...s,
+	text: s.text.replace(/\r\n|\r|\n/g, " ")
+}));
+/** Give every span without a token of its own this one. */
+const toned = (spans, token) => spans.map((s) => s.token === void 0 ? {
+	...s,
+	token
+} : s);
+const sliceSpans = (spans, end) => {
+	const out = [];
+	let left = end;
+	for (const s of spans) {
+		if (left <= 0) break;
+		out.push(s.text.length <= left ? s : {
+			...s,
+			text: s.text.slice(0, left)
+		});
+		left -= s.text.length;
+	}
+	return out;
+};
+/** The lines of a raw text, sanitized, without the empty line a trailing break would add. */
+const textLines = (text) => {
+	const lines = sanitize(text).split(/\r\n|\r|\n/);
+	return lines.length > 1 && lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines;
+};
+/** Join chunks with a separator, skipping empty ones. */
+const joinChunks = (chunks, separator) => chunks.filter((chunk) => chunk.length > 0).flatMap((chunk, index) => index === 0 ? chunk : [span(separator), ...chunk]);
+/** Join table cells with a separator, keeping an empty one: a column that is empty in every row still takes its place. */
+const joinCells = (cells, separator) => cells.flatMap((cell, index) => index === 0 ? cell : [span(separator), ...cell]);
+const blank = (width) => span(" ".repeat(width));
+const pad = (spans, width, align) => {
+	const gap = Math.max(0, width - widthOf(spans));
+	const before = align === "right" ? gap : align === "center" ? Math.floor(gap / 2) : 0;
+	const after = gap - before;
+	return [
+		...before > 0 ? [blank(before)] : [],
+		...spans,
+		...after > 0 ? [blank(after)] : []
+	];
+};
+/** Put `first` before the first line and `rest` before the others. */
+const hang = (lines, first, rest) => lines.length === 0 ? [trimLine(first)] : lines.map((line, index) => trimLine([...index === 0 ? first : rest, ...line]));
+/** A cap as a whole number of at least zero, or `undefined` for none. */
+const capOf = (cap) => cap === void 0 || Number.isNaN(cap) ? void 0 : Math.max(0, Math.floor(cap));
+const shrink = (widths, limit) => {
+	const gaps = 2 * Math.max(0, widths.length - 1);
+	const total = () => widths.reduce((sum, w) => sum + w, 0) + gaps;
+	while (total() > limit) {
+		let widest = 0;
+		for (let i = 1; i < widths.length; i++) if (widths[i] > widths[widest]) widest = i;
+		if ((widths[widest] ?? 0) <= 1) return;
+		widths[widest] = widths[widest] - 1;
+	}
+};
+const callouts = {
+	note: "info",
+	tip: "success",
+	important: "accent",
+	warning: "warning",
+	caution: "error"
+};
+const inline = ({ ctx, flavour }, inlines) => flavour.inline(inlines, ctx);
+const overflowLine = (walk, overflow, hidden) => toned(overflow === void 0 ? [span(`${walk.ctx.glyphs.ellipsis} ${hidden} more`)] : oneLine(inline(walk, overflow(hidden))), "muted");
+/** A table cell is one line: a line break is width 0 to a measure but breaks the row, so a cell keeps its first line. */
+const cellOf = (walk, inlines) => {
+	if (inlines === void 0) return [];
+	const spans = inline(walk, inlines);
+	const text = textOf(spans);
+	let end = text.length;
+	while (end > 0 && (text[end - 1] === "\n" || text[end - 1] === "\r")) end--;
+	const joined = text.slice(0, end);
+	const at = joined.search(/\r\n|\r|\n/);
+	if (at < 0) return sliceSpans(spans, joined.length);
+	return [...sliceSpans(spans, at), span(walk.ctx.glyphs.ellipsis, "muted")];
+};
+const tableLines = (walk, block, width) => {
+	const columns = Math.max(block.columns.length, ...block.rows.map((row) => row.length));
+	if (columns === 0) return [];
+	const cap = capOf(block.cap);
+	const shown = cap === void 0 ? block.rows : block.rows.slice(0, cap);
+	const header = Array.from({ length: columns }, (_, index) => toned(cellOf(walk, block.columns[index]?.header), "emphasis"));
+	const body = shown.map((row) => Array.from({ length: columns }, (_, index) => cellOf(walk, row[index])));
+	const showHeader = header.some((cell) => cell.length > 0);
+	const hidden = block.rows.length - shown.length;
+	if (!showHeader && body.length === 0) return hidden > 0 ? [overflowLine(walk, block.overflow, hidden)] : [];
+	const widths = Array.from({ length: columns }, (_, index) => Math.max(0, ...[...showHeader ? [header] : [], ...body].map((row) => widthOf(row[index] ?? []))));
+	shrink(widths, width);
+	const render = (row) => trimLine(joinCells(row.map((cell, index) => {
+		const columnWidth = widths[index];
+		const cut = widthOf(cell) > columnWidth ? truncateSpans(cell, columnWidth, walk.ctx.glyphs.ellipsis) : cell;
+		return pad(cut, columnWidth, block.columns[index]?.align ?? "left");
+	}), "  "));
+	const rule = joinCells(widths.map((w) => [span("-".repeat(w), "muted")]), "  ");
+	if (block.style === "pipe") {
+		const pipeRule = [span(widths.map((w, index) => "-".repeat(w + (index === 0 ? 1 : 2))).join("|"), "muted")];
+		const pipeRow = (row) => trimLine(joinCells(row.map((cell, index) => {
+			const columnWidth = widths[index];
+			const cut = widthOf(cell) > columnWidth ? truncateSpans(cell, columnWidth, walk.ctx.glyphs.ellipsis) : cell;
+			return pad(cut, columnWidth, block.columns[index]?.align ?? "left");
+		}), " | "));
+		const piped = [
+			...showHeader ? [pipeRule, pipeRow(header)] : [],
+			pipeRule,
+			...body.map(pipeRow),
+			pipeRule
+		];
+		return hidden > 0 ? [...piped, overflowLine(walk, block.overflow, hidden)] : piped;
+	}
+	const lines = [...showHeader ? [render(header), rule] : [], ...body.map(render)];
+	return hidden > 0 ? [...lines, overflowLine(walk, block.overflow, hidden)] : lines;
+};
+const treeLines = (walk, block) => {
+	const glyphs = walk.ctx.glyphs.tree;
+	const lines = [trimLine(oneLine(inline(walk, block.root.label)))];
+	const visit = (children, prefix) => {
+		children.forEach((child, index) => {
+			const last = index === children.length - 1;
+			lines.push(trimLine([span(prefix + (last ? glyphs.last : glyphs.branch), "muted"), ...oneLine(inline(walk, child.label))]));
+			visit(child.children, prefix + (last ? glyphs.blank : glyphs.pipe));
+		});
+	};
+	visit(block.root.children, "");
+	return lines;
+};
+const diffSide = (walk, marker, token, text, cap) => {
+	const lines = textLines(text);
+	const shown = cap === void 0 ? lines : lines.slice(0, cap);
+	const hidden = lines.length - shown.length;
+	return [...shown.map((line) => trimLine([span(`${marker} ${line}`, token)])), ...hidden > 0 ? [[span(`  ${walk.ctx.glyphs.ellipsis} ${hidden} more lines`, "muted")]] : []];
+};
+/** What a `Counts` block's `paint` keeps: every token, only a status glyph's, or none. */
+const keepPaint = (paint, lines) => {
+	if (paint === void 0 || paint === "all") return lines;
+	const unpainted = (s) => {
+		const { token: _token, ...rest } = s;
+		return rest;
+	};
+	return lines.map((line) => line.map((s) => paint === "glyph" && s.glyph === true ? s : unpainted(s)));
+};
+/** An annotation is only `githubLog`'s; every other renderer skips it, without leaving a gap where it stood. */
+const isAnnotation = (block) => block._tag === "Annotation";
+const countsLines = (walk, block) => keepPaint(block.paint, countsLayout(walk, block));
+const countsLayout = (walk, block) => {
+	const visible = visibleCountersOf(block);
+	const total = totalOf(block);
+	const label = block.label === void 0 ? [] : toned(oneLine(inline(walk, block.label)), "emphasis");
+	const qualifier = block.qualifier === void 0 ? [] : toned(oneLine(inline(walk, block.qualifier)), "muted");
+	const duration = block.durationMs === void 0 ? "" : Fmt.duration(block.durationMs);
+	const suffix = block.suffix === void 0 ? [] : toned(oneLine(inline(walk, block.suffix)), "muted");
+	const nameOf = (counter) => sanitize(counter.label).replace(/\r\n|\r|\n/g, " ");
+	const counters = visible.map((counter, index) => {
+		const name = nameOf(counter);
+		const share = index === 0 && block.share !== false;
+		return [span(share ? `${counter.n}/${total} ${name}` : `${counter.n} ${name}`, counter.status.def.token)];
+	});
+	if (block.layout === "row") return [trimLine(joinChunks([
+		label,
+		...counters,
+		qualifier,
+		duration === "" ? [] : [span(duration, "muted")],
+		suffix
+	], "  "))];
+	if (block.layout === "columns") {
+		const labelWidth = Math.max(0, ...visible.map((counter) => widthOf([span(nameOf(counter))])));
+		const numberWidth = Math.max(0, ...visible.map((counter) => String(counter.n).length));
+		return [
+			...label.length === 0 ? [] : [label],
+			...visible.map((counter) => trimLine([
+				...pad([span(nameOf(counter), counter.status.def.token)], labelWidth, "left"),
+				span("  "),
+				...pad([span(String(counter.n), counter.status.def.token)], numberWidth, "right")
+			])),
+			...qualifier.length === 0 ? [] : [qualifier],
+			...duration === "" ? [] : [[span(duration, "muted")]],
+			...suffix.length === 0 ? [] : [suffix]
+		];
+	}
+	const head = label.length === 0 ? [] : [...label, span(":")];
+	const tally = joinChunks(counters, ", ");
+	return [trimLine(joinChunks([
+		joinChunks([head, tally], " "),
+		qualifier,
+		duration === "" ? [] : [span(`(${duration})`, "muted")],
+		suffix
+	], " "))];
+};
+/**
+* A block as lines. `compact` is set on a compact list's item: a section there joins its title and children with no
+* blank lines between them.
+*/
+const blockLines = (walk, block, width, compact = false) => {
+	switch (block._tag) {
+		case "Heading": return [trimLine(toned(oneLine(inline(walk, block.content)), "emphasis"))];
+		case "Paragraph": {
+			const spans = inline(walk, block.content);
+			if (spans.length === 0) return [[]];
+			return wrapSpans(spans, width, { hardBreak: false }).map(trimLine);
+		}
+		case "List": {
+			const cap = capOf(block.cap);
+			const items = block.items.filter((item) => !isAnnotation(item));
+			const shown = cap === void 0 ? items : items.slice(0, cap);
+			const compactItems = block.compact === true;
+			const lines = shown.flatMap((item) => hang(blockLines(walk, item, width - 2, compactItems), [span("- ")], [span("  ")]).map((line, index) => compactItems && index > 0 && line.length === 0 ? [{
+				text: "  ",
+				hold: true
+			}] : line));
+			const hidden = items.length - shown.length;
+			return hidden > 0 ? [...lines, overflowLine(walk, block.overflow, hidden)] : lines;
+		}
+		case "Table": return tableLines(walk, block, width);
+		case "Tree": return treeLines(walk, block);
+		case "Collapsible": return [trimLine(toned(oneLine(inline(walk, block.title)), "emphasis")), ...block.body.flatMap((child) => blockLines(walk, child, width - 2)).map((line) => trimLine([span("  "), ...line]))];
+		case "Callout": {
+			const label = `${block.kind.toUpperCase()}:`;
+			const hanging = label.length + 1;
+			const body = block.body.flatMap((child) => blockLines(walk, child, width - hanging));
+			const head = span(label, callouts[block.kind]);
+			return body.length === 0 ? [[head]] : hang(body, [head, span(" ")], [blank(hanging)]);
+		}
+		case "CodeBlock": return textLines(block.text).map((line) => trimLine([span(`    ${line}`)]));
+		case "Diff": {
+			const cap = capOf(block.cap);
+			return [...diffSide(walk, "-", "failure", block.expected, cap), ...diffSide(walk, "+", "success", block.received, cap)];
+		}
+		case "Section": return [...block.title === void 0 ? [] : [[trimLine(toned(oneLine(inline(walk, block.title)), "emphasis"))]], ...block.children.filter((child) => !isAnnotation(child)).map((child) => blockLines(walk, child, width))].flatMap((group, index) => index === 0 || compact ? group : [[], ...group]);
+		case "Counts": return countsLines(walk, block);
+		case "Verbatim": {
+			const indent = " ".repeat(Math.max(0, Math.floor(block.indent ?? 0)));
+			return textLines(block.text).map((line) => trimLine([span(`${indent}${line}`)]));
+		}
+		case "Annotation": return [];
+		case "CountsTable": return tableLines(walk, countsTableOf(block), width);
+		case "Lines": return block.lines.flatMap((entry) => {
+			const spans = inline(walk, entry);
+			return spans.length === 0 ? [[]] : wrapSpans(spans, width, { hardBreak: false }).map(trimLine);
+		});
+		case "Line": {
+			const spans = oneLine(inline(walk, block.content));
+			if (block.truncate === true) return [trimLine(truncateSpans(spans, width, walk.ctx.glyphs.ellipsis))];
+			return spans.length === 0 ? [[]] : wrapSpans(spans, width, { hardBreak: false }).map(trimLine);
+		}
+		case "DiffText": {
+			const cap = capOf(block.cap);
+			const lines = textLines(block.text);
+			const shown = cap === void 0 ? lines : lines.slice(0, cap);
+			const hidden = lines.length - shown.length;
+			const tone = (line) => line.startsWith("+") ? "success" : line.startsWith("-") ? "failure" : void 0;
+			const cut = (spans) => block.truncate === true ? truncateSpans(spans, width, walk.ctx.glyphs.ellipsis) : spans;
+			return [...shown.map((line) => trimLine(cut([span(line, tone(line))]))), ...hidden > 0 ? [[span(`${walk.ctx.glyphs.ellipsis} ${hidden} more lines`, "muted")]] : []];
+		}
+	}
+};
+/**
+* Render a document to its finished lines in the given flavour: a block that draws nothing contributes no line, where
+* the joined string could not tell it from one empty line.
+*
+* @internal
+*/
+const renderDocLines = (doc, ctx, flavour) => {
+	const width = Number.isNaN(ctx.width) ? 80 : Math.max(1, ctx.width);
+	const walk = {
+		ctx,
+		flavour
+	};
+	return doc.flatMap((block) => blockLines(walk, block, width)).map((line) => flavour.finish(trimLine(line), ctx));
+};
+/**
+* Render a document to lines of text in the given flavour.
+*
+* @internal
+*/
+const renderDoc = (doc, ctx, flavour) => renderDocLines(doc, ctx, flavour).join("\n");
+
+//#endregion
+export { capOf, isAnnotation, renderDoc, renderDocLines, showsSuffix, targetText, textLines, trimLine };

package/internal/renderGithubLog.js

@@ -0,0 +1,46 @@
+import { sanitize } from "../Fmt.js";
+import { plainInline, renderPlainLines } from "./renderPlain.js";
+import { CommandNeutralizer, WorkflowCommand } from "@effected/github-commands";
+
+//#region src/internal/renderGithubLog.ts
+/** Plain lines, neutralized; a block that draws nothing, such as an empty table, gives no line at all. */
+const plainLines = (blocks, ctx) => renderPlainLines(blocks, ctx).flatMap((line) => CommandNeutralizer.lines(line));
+/** An annotation as the kit's own command, on the trusted path: escaped by `WorkflowCommand`, never neutralized. */
+const annotationLine = (block) => WorkflowCommand[block.level](sanitize(block.message), {
+	...block.title === void 0 ? {} : { title: sanitize(block.title) },
+	...block.file === void 0 ? {} : { file: sanitize(block.file) },
+	...block.line === void 0 ? {} : { startLine: block.line },
+	...block.endLine === void 0 ? {} : { endLine: block.endLine },
+	...block.col === void 0 ? {} : { startColumn: block.col },
+	...block.endColumn === void 0 ? {} : { endColumn: block.endColumn }
+});
+/** A group's body: plain text, except an annotation, which is still a command inside a group. */
+const bodyLines = (blocks, ctx) => blocks.flatMap((block) => block._tag === "Annotation" ? [annotationLine(block)] : plainLines([block], ctx));
+const blockLines = (block, ctx) => {
+	switch (block._tag) {
+		case "Annotation": return [annotationLine(block)];
+		case "Collapsible": {
+			const title = plainInline(block.title, ctx).map((span) => span.text).join("");
+			return [
+				WorkflowCommand.group(title),
+				...bodyLines(block.body, ctx),
+				WorkflowCommand.endGroup()
+			];
+		}
+		case "Section": return [...block.title === void 0 ? [] : [plainLines([{
+			_tag: "Heading",
+			level: 1,
+			content: block.title
+		}], ctx)], ...block.children.map((child) => blockLines(child, ctx))].flatMap((group, index) => index === 0 ? group : ["", ...group]);
+		default: return plainLines([block], ctx);
+	}
+};
+/**
+* Render a document for a GitHub Actions log: plain text, with a top-level collapsible as a group.
+*
+* @internal
+*/
+const renderGithubLog = (doc, ctx) => doc.flatMap((block) => blockLines(block, ctx)).join("\n");
+
+//#endregion
+export { renderGithubLog };