@zenodinh/pi-render 0.0.0-stage → 0.1.0

package/src/renderers/content/artifacts/cards.ts

@@ -0,0 +1,136 @@
+// ported from pi-pretty-tui/src/features/canvas/{card,emit}.ts — survives because: the boxed card with
+// a plain-markdown Open link is what the host turns into a real clickable target, and imageLineMetadata
+// is the one place a raster artifact's row count is known (T-25's cache meta leaves rows to this step).
+// The emit.ts terminal-image emission is NOT ported: pi-render draws no inline pixels (the artifact card
+// is the transcript output), so those lines had no caller, and their iTerm2 branch carried a cursor-up
+// escape literal — the repo keeps escapes in src/core/paint.ts alone.
+
+/**
+ * cards.ts — the artifact card and the raster row count.
+ *
+ * Boundary: the Open link resolves through the ArtifactServer, which registers the path as carded and
+ * names the loopback URL; a degraded server is logged once by urlFor and the card falls back to a
+ * file:// URL, so a failed bind never reaches the render path as a throw.
+ *
+ * shape: none — no module-level state; every export is a straight-line function or one box builder.
+ */
+
+import { pathToFileURL } from "node:url";
+import { calculateImageRows, getImageDimensions, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { ContentPaint } from "../../../core/types/paint.ts";
+import type { ArtifactServer } from "./server.ts";
+
+const OPEN_LABEL = "Open (⌘click)";
+const COPY_LABEL = "Copy path (⌥C)";
+/** The rendered link occupies brackets around the label. */
+const OPEN_WIDTH = visibleWidth(OPEN_LABEL) + 2;
+/** Cards read best narrow; the offered width is clamped into these bounds. */
+const CARD_MIN_WIDTH = 24;
+const CARD_MAX_WIDTH = 64;
+/** pi-tui's default image width; the reference for a raster artifact's transcript row count. */
+const DEFAULT_WIDTH_CELLS = 60;
+
+/** The artifact card's own fields; the URL is resolved from the path, never supplied by the caller. */
+export interface ArtifactCardSpec {
+	/** The fence form, e.g. "plantuml" — rendered as the card's type label. */
+	typeLabel: string;
+	/** The artifact's own name where it has one; see artifactTitle. */
+	title: string;
+	/** Absolute path of the artifact on disk; the Open link points at it. */
+	path: string;
+	/** Offered transcript width in columns. */
+	width: number;
+}
+
+/** Markdown would eat these inside a label; escaping keeps the title literal. */
+function escapeMarkdown(text: string): string {
+	return text.replace(/([\\`*_[\]#])/g, "\\$1");
+}
+
+function clampWidth(text: string, width: number): string {
+	return visibleWidth(text) > width ? truncateToWidth(text, width) : text;
+}
+
+/**
+ * The artifact names itself where it can; the caller passes the fallback (`form`) otherwise.
+ *
+ * shape: none — dispatch object does not apply: one `||` form test plus ordered title extraction.
+ */
+export function artifactTitle(form: string, source: string): string {
+	const plantumlStart = source.match(/@start\w+\s+"([^"\n]+)"/);
+	if (plantumlStart?.[1]) return plantumlStart[1].trim();
+	const plantumlTitle = source.match(/^\s*title\s+(.+)$/m);
+	if (plantumlTitle?.[1]) return plantumlTitle[1].trim();
+	if (form === "svg" || form === "html") {
+		const tag = source.match(/<title[^>]*>([^<]*)<\/title>/i);
+		if (tag?.[1]) return tag[1].trim();
+		const heading = source.match(/<h1[^>]*>([^<]+)<\/h1>/i);
+		if (heading?.[1]) return heading[1].trim();
+	}
+	return form;
+}
+
+/** shape: none — one box; every line's visible width is arithmetically bounded. */
+function renderCard(spec: ArtifactCardSpec & { openUrl: string; pathLabel: string }, paint: ContentPaint): string {
+	const width = Math.max(CARD_MIN_WIDTH, Math.min(Math.floor(spec.width), CARD_MAX_WIDTH));
+	const inner = width - 2;
+	const contentWidth = Math.max(OPEN_WIDTH + 2, inner - 2);
+	const label = spec.typeLabel.toLowerCase();
+	const prefix = `─ ${label} `;
+	const dashes = Math.max(0, inner - visibleWidth(prefix));
+	const headerLine = paint.rule(`╭${prefix}${"─".repeat(dashes)}╮`);
+
+	const title = escapeMarkdown(spec.title);
+	// A link whose raw text cannot fit the line must not be emitted: the host wraps by RAW width, would
+	// split the token mid-way and print literal brackets with the URL dropped. It then degrades to the
+	// plain label, and the path line stays the way in.
+	const link = `[${OPEN_LABEL}](${spec.openUrl})`;
+	const linkFits = visibleWidth(link) <= Math.max(4, contentWidth - 1);
+	const titleBudget = contentWidth - (linkFits ? visibleWidth(link) : visibleWidth(OPEN_LABEL)) - 1;
+	const titleFitted = clampWidth(title, Math.max(1, titleBudget));
+	const actionText = linkFits ? link : OPEN_LABEL;
+	const titlePad = " ".repeat(Math.max(1, contentWidth - visibleWidth(titleFitted) - visibleWidth(actionText)));
+	// No escape codes inside the brackets: anything there breaks the link token.
+	const titleLine = `${paint.rule("│")} ${paint.quote(titleFitted)}${titlePad}${actionText} ${paint.rule("│")}`;
+	const copyPad = " ".repeat(Math.max(0, contentWidth - visibleWidth(COPY_LABEL)));
+	const copyLine = `${paint.rule("│")} ${paint.quote(COPY_LABEL)}${copyPad} ${paint.rule("│")}`;
+
+	// The full path is shown, wrapped — truncation is what made it useless to copy.
+	const safePath = spec.pathLabel.replace(/`/g, "'");
+	const chunkWidth = Math.max(8, contentWidth);
+	const chunks: string[] = [];
+	for (let index = 0; index < safePath.length; index += chunkWidth)
+		chunks.push(safePath.slice(index, index + chunkWidth));
+	if (chunks.length === 0) chunks.push("");
+	const pathLines = chunks
+		.map((chunk) => {
+			const pad = " ".repeat(Math.max(0, contentWidth - visibleWidth(chunk)));
+			return `${paint.rule("│")} ${paint.quote(chunk)}${pad} ${paint.rule("│")}`;
+		})
+		.join("  \n");
+	const bottomLine = paint.rule(`╰${"─".repeat(inner)}╯`);
+
+	// Hard breaks keep the box adjacent; the title line carries the link.
+	return `${headerLine}  \n${titleLine}  \n${copyLine}  \n${pathLines}  \n${bottomLine}\n`;
+}
+
+/**
+ * shape: none — one URL resolution plus one box build; the degrade branch lives in urlFor, not here.
+ */
+export function renderArtifactCard(server: ArtifactServer, spec: ArtifactCardSpec, paint: ContentPaint): string {
+	// urlFor registers the path as carded and names the loopback URL; a degraded server logs once and
+	// the card falls back to a file:// link, so the session never sees the failure.
+	const openUrl = server.urlFor(spec.path) ?? pathToFileURL(spec.path).href;
+	return renderCard({ ...spec, openUrl, pathLabel: spec.path }, paint);
+}
+
+/**
+ * The transcript row count of a raster artifact: the height the host's image fit would occupy.
+ *
+ * shape: none — one parse plus one arithmetic; no dispatch.
+ */
+export function imageLineMetadata(base64: string): { rows: number } {
+	const dimensions = getImageDimensions(base64, "image/png");
+	if (!dimensions) return { rows: 1 };
+	return { rows: Math.max(1, calculateImageRows(dimensions, DEFAULT_WIDTH_CELLS)) };
+}