@dungle-scrubs/tallow 0.9.3 → 0.9.6

package/node_modules/@mariozechner/pi-tui/src/components/loader.ts

@@ -1,141 +1,36 @@
 import type { TUI } from "../tui.js";
 import { Text } from "./text.js";
 
-/** Default braille spinner frames used when no custom frames are provided. */
-const DEFAULT_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-
-/** Default animation interval in milliseconds. */
-const DEFAULT_INTERVAL_MS = 80;
-
-/** Optional configuration for the Loader's spinner appearance and timing. */
-export interface LoaderOptions {
-	/** Spinner animation frames (defaults to braille dots). */
-	frames?: string[];
-	/** Animation interval in ms (default: 80). */
-	intervalMs?: number;
-}
-
-/** Context passed to the message transform callback each tick. */
-export interface MessageTransformContext {
-	/** The current message set on this Loader (from constructor or setMessage). */
-	message: string;
-	/** Monotonic tick counter — increments each animation frame for this instance. */
-	tick: number;
-	/** True if the message has not been changed via setMessage() since construction. */
-	isInitialMessage: boolean;
-}
-
 /**
- * Loader component that updates with a spinning animation.
- *
- * @param ui - TUI instance for rendering
- * @param spinnerColorFn - Color function applied to the spinner frame
- * @param messageColorFn - Color function applied to the message text
- * @param message - Text shown next to the spinner (default: "Loading...")
- * @param options - Optional frames and interval override
+ * Loader component that updates every 80ms with spinning animation
  */
 export class Loader extends Text {
-	private frames: string[];
-	private intervalMs: number;
+	private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 	private currentFrame = 0;
 	private intervalId: NodeJS.Timeout | null = null;
-	private _transformIntervalId: NodeJS.Timeout | null = null;
 	private ui: TUI | null = null;
 
-	/** Per-instance tick counter for message transform animations. */
-	private _transformTick = 0;
-
-	/** Tracks whether setMessage() has been called since construction. */
-	private _messageChanged = false;
-
 	constructor(
 		ui: TUI,
 		private spinnerColorFn: (str: string) => string,
 		private messageColorFn: (str: string) => string,
-		private message: string = "Loading...",
-		options?: LoaderOptions
+		private message: string = "Loading..."
 	) {
 		super("", 1, 0);
-		this.frames = options?.frames ?? Loader.defaultFrames ?? DEFAULT_FRAMES;
-		this.intervalMs = options?.intervalMs ?? Loader.defaultIntervalMs ?? DEFAULT_INTERVAL_MS;
 		this.ui = ui;
 		this.start();
 	}
 
-	/**
-	 * Global default spinner frames — set once, applies to all new Loader instances.
-	 * Extensions can set this at session_start to override the braille default.
-	 */
-	static defaultFrames: string[] | undefined;
-
-	/**
-	 * Global default interval — set once, applies to all new Loader instances.
-	 */
-	static defaultIntervalMs: number | undefined;
-
-	/**
-	 * Global message transform — called each tick to modify the displayed message.
-	 * Extensions use this to animate or replace the loader text.
-	 * Return the string to display. The transform is applied before messageColorFn.
-	 */
-	static defaultMessageTransform?: (ctx: MessageTransformContext) => string;
-
-	/**
-	 * Interval (ms) for the message transform tick — independent of the spinner frame rate.
-	 * When set to a value faster than the spinner interval, a separate timer drives
-	 * the transform tick and re-renders, giving animations higher
-	 * frame rates without affecting the spinner animation speed.
-	 */
-	static defaultTransformIntervalMs: number | undefined;
-
-	/** Whether the loader is hidden (renders as empty space). */
-	private hidden = false;
-
-	/**
-	 * Hide the loader — renders nothing but keeps the interval alive.
-	 * Call show() to restore.
-	 */
-	hide() {
-		this.hidden = true;
-		this.setText("");
-		this.ui?.requestRender();
-	}
-
-	/**
-	 * Show the loader after a hide() call.
-	 */
-	show() {
-		this.hidden = false;
-		this.updateDisplay();
-	}
-
 	render(width: number): string[] {
-		if (this.hidden) return [];
 		return ["", ...super.render(width)];
 	}
 
 	start() {
 		this.updateDisplay();
-
-		const transformMs = Loader.defaultTransformIntervalMs;
-		const hasFastTransform =
-			Loader.defaultMessageTransform != null &&
-			transformMs != null &&
-			transformMs < this.intervalMs;
-
 		this.intervalId = setInterval(() => {
 			this.currentFrame = (this.currentFrame + 1) % this.frames.length;
-			this._transformTick++;
 			this.updateDisplay();
-		}, this.intervalMs);
-
-		// Separate faster interval for message transform re-renders only.
-		// Does NOT advance _transformTick — just re-rolls random visuals.
-		if (hasFastTransform) {
-			this._transformIntervalId = setInterval(() => {
-				this.updateDisplay();
-			}, transformMs);
-		}
+		}, 80);
 	}
 
 	stop() {
@@ -143,43 +38,16 @@ export class Loader extends Text {
 			clearInterval(this.intervalId);
 			this.intervalId = null;
 		}
-		if (this._transformIntervalId) {
-			clearInterval(this._transformIntervalId);
-			this._transformIntervalId = null;
-		}
 	}
 
-	/** Sentinel value — pass to setWorkingMessage() to hide the loader. */
-	static readonly HIDE = "\u200B";
-
-	/**
-	 * Set the loader message. Pass Loader.HIDE to hide, any other string to show.
-	 * @param message - Message text or Loader.HIDE sentinel
-	 */
 	setMessage(message: string) {
-		if (message === Loader.HIDE) {
-			this.hide();
-			return;
-		}
-		if (this.hidden) this.show();
-		this._messageChanged = true;
 		this.message = message;
 		this.updateDisplay();
 	}
 
 	private updateDisplay() {
 		const frame = this.frames[this.currentFrame];
-		let displayMessage = this.message;
-
-		if (Loader.defaultMessageTransform) {
-			displayMessage = Loader.defaultMessageTransform({
-				message: this.message,
-				tick: this._transformTick,
-				isInitialMessage: !this._messageChanged,
-			});
-		}
-
-		this.setText(`${this.spinnerColorFn(frame)} ${this.messageColorFn(displayMessage)}`);
+		this.setText(`${this.spinnerColorFn(frame)} ${this.messageColorFn(this.message)}`);
 		if (this.ui) {
 			this.ui.requestRender();
 		}

package/node_modules/@mariozechner/pi-tui/src/components/markdown.ts

@@ -1,8 +1,32 @@
-import { marked, type Token } from "marked";
-import { isImageLine } from "../terminal-image.js";
+import { Marked, type Token, Tokenizer, type Tokens } from "marked";
+import { getCapabilities, hyperlink, isImageLine } from "../terminal-image.js";
 import type { Component } from "../tui.js";
 import { applyBackgroundToLine, visibleWidth, wrapTextWithAnsi } from "../utils.js";
 
+const STRICT_STRIKETHROUGH_REGEX = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
+
+class StrictStrikethroughTokenizer extends Tokenizer {
+	override del(src: string): Tokens.Del | undefined {
+		const match = STRICT_STRIKETHROUGH_REGEX.exec(src);
+		if (!match) {
+			return undefined;
+		}
+
+		const text = match[2];
+		return {
+			type: "del",
+			raw: match[0],
+			text,
+			tokens: this.lexer.inlineTokens(text),
+		};
+	}
+}
+
+const markdownParser = new Marked();
+markdownParser.setOptions({
+	tokenizer: new StrictStrikethroughTokenizer(),
+});
+
 /**
  * Default text styling for markdown content.
  * Applied to all text unless overridden by markdown formatting.
@@ -112,7 +136,7 @@ export class Markdown implements Component {
 		const normalizedText = this.text.replace(/\t/g, "   ");
 
 		// Parse markdown to HTML-like tokens
-		const tokens = marked.lexer(normalizedText);
+		const tokens = markdownParser.lexer(normalizedText);
 
 		// Convert tokens to styled terminal output
 		const renderedLines: string[] = [];
@@ -260,31 +284,47 @@ export class Markdown implements Component {
 		};
 	}
 
-	private renderToken(token: Token, width: number, nextTokenType?: string): string[] {
+	private renderToken(
+		token: Token,
+		width: number,
+		nextTokenType?: string,
+		styleContext?: InlineStyleContext
+	): string[] {
 		const lines: string[] = [];
 
 		switch (token.type) {
 			case "heading": {
 				const headingLevel = token.depth;
 				const headingPrefix = `${"#".repeat(headingLevel)} `;
-				const headingText = this.renderInlineTokens(token.tokens || []);
-				let styledHeading: string;
+
+				// Build a heading-specific style context so inline tokens (codespan, bold, etc.)
+				// restore heading styling after their own ANSI resets instead of falling back to
+				// the default text style.
+				let headingStyleFn: (text: string) => string;
 				if (headingLevel === 1) {
-					styledHeading = this.theme.heading(this.theme.bold(this.theme.underline(headingText)));
-				} else if (headingLevel === 2) {
-					styledHeading = this.theme.heading(this.theme.bold(headingText));
+					headingStyleFn = (text: string) =>
+						this.theme.heading(this.theme.bold(this.theme.underline(text)));
 				} else {
-					styledHeading = this.theme.heading(this.theme.bold(headingPrefix + headingText));
+					headingStyleFn = (text: string) => this.theme.heading(this.theme.bold(text));
 				}
+
+				const headingStyleContext: InlineStyleContext = {
+					applyText: headingStyleFn,
+					stylePrefix: this.getStylePrefix(headingStyleFn),
+				};
+
+				const headingText = this.renderInlineTokens(token.tokens || [], headingStyleContext);
+				const styledHeading =
+					headingLevel >= 3 ? headingStyleFn(headingPrefix) + headingText : headingText;
 				lines.push(styledHeading);
-				if (nextTokenType !== "space") {
+				if (nextTokenType && nextTokenType !== "space") {
 					lines.push(""); // Add spacing after headings (unless space token follows)
 				}
 				break;
 			}
 
 			case "paragraph": {
-				const paragraphText = this.renderInlineTokens(token.tokens || []);
+				const paragraphText = this.renderInlineTokens(token.tokens || [], styleContext);
 				lines.push(paragraphText);
 				// Don't add spacing if next token is space or list
 				if (nextTokenType && nextTokenType !== "list" && nextTokenType !== "space") {
@@ -309,14 +349,14 @@ export class Markdown implements Component {
 					}
 				}
 				lines.push(this.theme.codeBlockBorder("```"));
-				if (nextTokenType !== "space") {
+				if (nextTokenType && nextTokenType !== "space") {
 					lines.push(""); // Add spacing after code blocks (unless space token follows)
 				}
 				break;
 			}
 
 			case "list": {
-				const listLines = this.renderList(token as any, 0);
+				const listLines = this.renderList(token as any, 0, styleContext);
 				lines.push(...listLines);
 				// Don't add spacing after lists if a space token follows
 				// (the space token will handle it)
@@ -324,31 +364,63 @@ export class Markdown implements Component {
 			}
 
 			case "table": {
-				const tableLines = this.renderTable(token as any, width);
+				const tableLines = this.renderTable(token as any, width, nextTokenType, styleContext);
 				lines.push(...tableLines);
 				break;
 			}
 
 			case "blockquote": {
 				const quoteStyle = (text: string) => this.theme.quote(this.theme.italic(text));
-				const quoteStyleContext: InlineStyleContext = {
-					applyText: quoteStyle,
-					stylePrefix: this.getStylePrefix(quoteStyle),
+				const quoteStylePrefix = this.getStylePrefix(quoteStyle);
+				const applyQuoteStyle = (line: string): string => {
+					if (!quoteStylePrefix) {
+						return quoteStyle(line);
+					}
+					const lineWithReappliedStyle = line.replace(/\x1b\[0m/g, `\x1b[0m${quoteStylePrefix}`);
+					return quoteStyle(lineWithReappliedStyle);
 				};
-				const quoteText = this.renderInlineTokens(token.tokens || [], quoteStyleContext);
-				const quoteLines = quoteText.split("\n");
 
 				// Calculate available width for quote content (subtract border "│ " = 2 chars)
 				const quoteContentWidth = Math.max(1, width - 2);
 
-				for (const quoteLine of quoteLines) {
-					// Wrap the styled line, then add border to each wrapped line
-					const wrappedLines = wrapTextWithAnsi(quoteLine, quoteContentWidth);
+				// Blockquotes contain block-level tokens (paragraph, list, code, etc.), so render
+				// children with renderToken() instead of renderInlineTokens().
+				// Default message style should not apply inside blockquotes.
+				const quoteInlineStyleContext: InlineStyleContext = {
+					applyText: (text: string) => text,
+					stylePrefix: quoteStylePrefix,
+				};
+				const quoteTokens = token.tokens || [];
+				const renderedQuoteLines: string[] = [];
+				for (let i = 0; i < quoteTokens.length; i++) {
+					const quoteToken = quoteTokens[i];
+					const nextQuoteToken = quoteTokens[i + 1];
+					renderedQuoteLines.push(
+						...this.renderToken(
+							quoteToken,
+							quoteContentWidth,
+							nextQuoteToken?.type,
+							quoteInlineStyleContext
+						)
+					);
+				}
+
+				// Avoid rendering an extra empty quote line before the outer blockquote spacing.
+				while (
+					renderedQuoteLines.length > 0 &&
+					renderedQuoteLines[renderedQuoteLines.length - 1] === ""
+				) {
+					renderedQuoteLines.pop();
+				}
+
+				for (const quoteLine of renderedQuoteLines) {
+					const styledLine = applyQuoteStyle(quoteLine);
+					const wrappedLines = wrapTextWithAnsi(styledLine, quoteContentWidth);
 					for (const wrappedLine of wrappedLines) {
 						lines.push(this.theme.quoteBorder("│ ") + wrappedLine);
 					}
 				}
-				if (nextTokenType !== "space") {
+				if (nextTokenType && nextTokenType !== "space") {
 					lines.push(""); // Add spacing after blockquotes (unless space token follows)
 				}
 				break;
@@ -356,7 +428,7 @@ export class Markdown implements Component {
 
 			case "hr":
 				lines.push(this.theme.hr("─".repeat(Math.min(width, 80))));
-				if (nextTokenType !== "space") {
+				if (nextTokenType && nextTokenType !== "space") {
 					lines.push(""); // Add spacing after horizontal rules (unless space token follows)
 				}
 				break;
@@ -426,20 +498,24 @@ export class Markdown implements Component {
 
 				case "link": {
 					const linkText = this.renderInlineTokens(token.tokens || [], resolvedStyleContext);
-					// If link text matches href, only show the link once
-					// Compare raw text (token.text) not styled text (linkText) since linkText has ANSI codes
-					// For mailto: links, strip the prefix before comparing (autolinked emails have
-					// text="foo@bar.com" but href="mailto:foo@bar.com")
-					const hrefForComparison = token.href.startsWith("mailto:")
-						? token.href.slice(7)
-						: token.href;
-					if (token.text === token.href || token.text === hrefForComparison) {
-						result += this.theme.link(this.theme.underline(linkText)) + stylePrefix;
+					const styledLink = this.theme.link(this.theme.underline(linkText));
+					if (getCapabilities().hyperlinks) {
+						// OSC 8: render as a clickable hyperlink. The URL is not printed inline,
+						// so we always show only the link text regardless of whether it matches href.
+						result += hyperlink(styledLink, token.href) + stylePrefix;
 					} else {
-						result +=
-							this.theme.link(this.theme.underline(linkText)) +
-							this.theme.linkUrl(` (${token.href})`) +
-							stylePrefix;
+						// Fallback: print URL in parentheses when text differs from href.
+						// Compare raw token.text (not styled) against href for the equality check.
+						// For mailto: links strip the prefix (autolinked emails use text="foo@bar.com"
+						// but href="mailto:foo@bar.com").
+						const hrefForComparison = token.href.startsWith("mailto:")
+							? token.href.slice(7)
+							: token.href;
+						if (token.text === token.href || token.text === hrefForComparison) {
+							result += styledLink + stylePrefix;
+						} else {
+							result += styledLink + this.theme.linkUrl(` (${token.href})`) + stylePrefix;
+						}
 					}
 					break;
 				}
@@ -469,6 +545,10 @@ export class Markdown implements Component {
 			}
 		}
 
+		while (stylePrefix && result.endsWith(stylePrefix)) {
+			result = result.slice(0, -stylePrefix.length);
+		}
+
 		return result;
 	}
 
@@ -477,7 +557,8 @@ export class Markdown implements Component {
 	 */
 	private renderList(
 		token: Token & { items: any[]; ordered: boolean; start?: number },
-		depth: number
+		depth: number,
+		styleContext?: InlineStyleContext
 	): string[] {
 		const lines: string[] = [];
 		const indent = "  ".repeat(depth);
@@ -489,7 +570,7 @@ export class Markdown implements Component {
 			const bullet = token.ordered ? `${startNumber + i}. ` : "- ";
 
 			// Process item tokens to handle nested lists
-			const itemLines = this.renderListItem(item.tokens || [], depth);
+			const itemLines = this.renderListItem(item.tokens || [], depth, styleContext);
 
 			if (itemLines.length > 0) {
 				// First line - check if it's a nested list
@@ -530,25 +611,29 @@ export class Markdown implements Component {
 	 * Render list item tokens, handling nested lists
 	 * Returns lines WITHOUT the parent indent (renderList will add it)
 	 */
-	private renderListItem(tokens: Token[], parentDepth: number): string[] {
+	private renderListItem(
+		tokens: Token[],
+		parentDepth: number,
+		styleContext?: InlineStyleContext
+	): string[] {
 		const lines: string[] = [];
 
 		for (const token of tokens) {
 			if (token.type === "list") {
 				// Nested list - render with one additional indent level
 				// These lines will have their own indent, so we just add them as-is
-				const nestedLines = this.renderList(token as any, parentDepth + 1);
+				const nestedLines = this.renderList(token as any, parentDepth + 1, styleContext);
 				lines.push(...nestedLines);
 			} else if (token.type === "text") {
 				// Text content (may have inline tokens)
 				const text =
 					token.tokens && token.tokens.length > 0
-						? this.renderInlineTokens(token.tokens)
+						? this.renderInlineTokens(token.tokens, styleContext)
 						: token.text || "";
 				lines.push(text);
 			} else if (token.type === "paragraph") {
 				// Paragraph in list item
-				const text = this.renderInlineTokens(token.tokens || []);
+				const text = this.renderInlineTokens(token.tokens || [], styleContext);
 				lines.push(text);
 			} else if (token.type === "code") {
 				// Code block in list item
@@ -568,7 +653,7 @@ export class Markdown implements Component {
 				lines.push(this.theme.codeBlockBorder("```"));
 			} else {
 				// Other token types - try to render as inline
-				const text = this.renderInlineTokens([token]);
+				const text = this.renderInlineTokens([token], styleContext);
 				if (text) {
 					lines.push(text);
 				}
@@ -609,7 +694,9 @@ export class Markdown implements Component {
 	 */
 	private renderTable(
 		token: Token & { header: any[]; rows: any[][]; raw?: string },
-		availableWidth: number
+		availableWidth: number,
+		nextTokenType?: string,
+		styleContext?: InlineStyleContext
 	): string[] {
 		const lines: string[] = [];
 		const numCols = token.header.length;
@@ -625,7 +712,9 @@ export class Markdown implements Component {
 		if (availableForCells < numCols) {
 			// Too narrow to render a stable table. Fall back to raw markdown.
 			const fallbackLines = token.raw ? wrapTextWithAnsi(token.raw, availableWidth) : [];
-			fallbackLines.push("");
+			if (nextTokenType && nextTokenType !== "space") {
+				fallbackLines.push("");
+			}
 			return fallbackLines;
 		}
 
@@ -635,13 +724,13 @@ export class Markdown implements Component {
 		const naturalWidths: number[] = [];
 		const minWordWidths: number[] = [];
 		for (let i = 0; i < numCols; i++) {
-			const headerText = this.renderInlineTokens(token.header[i].tokens || []);
+			const headerText = this.renderInlineTokens(token.header[i].tokens || [], styleContext);
 			naturalWidths[i] = visibleWidth(headerText);
 			minWordWidths[i] = Math.max(1, this.getLongestWordWidth(headerText, maxUnbrokenWordWidth));
 		}
 		for (const row of token.rows) {
 			for (let i = 0; i < row.length; i++) {
-				const cellText = this.renderInlineTokens(row[i].tokens || []);
+				const cellText = this.renderInlineTokens(row[i].tokens || [], styleContext);
 				naturalWidths[i] = Math.max(naturalWidths[i] || 0, visibleWidth(cellText));
 				minWordWidths[i] = Math.max(
 					minWordWidths[i] || 1,
@@ -729,7 +818,7 @@ export class Markdown implements Component {
 
 		// Render header with wrapping
 		const headerCellLines: string[][] = token.header.map((cell, i) => {
-			const text = this.renderInlineTokens(cell.tokens || []);
+			const text = this.renderInlineTokens(cell.tokens || [], styleContext);
 			return this.wrapCellText(text, columnWidths[i]);
 		});
 		const headerLineCount = Math.max(...headerCellLines.map((c) => c.length));
@@ -752,7 +841,7 @@ export class Markdown implements Component {
 		for (let rowIndex = 0; rowIndex < token.rows.length; rowIndex++) {
 			const row = token.rows[rowIndex];
 			const rowCellLines: string[][] = row.map((cell, i) => {
-				const text = this.renderInlineTokens(cell.tokens || []);
+				const text = this.renderInlineTokens(cell.tokens || [], styleContext);
 				return this.wrapCellText(text, columnWidths[i]);
 			});
 			const rowLineCount = Math.max(...rowCellLines.map((c) => c.length));
@@ -774,7 +863,9 @@ export class Markdown implements Component {
 		const bottomBorderCells = columnWidths.map((w) => "─".repeat(w));
 		lines.push(`└─${bottomBorderCells.join("─┴─")}─┘`);
 
-		lines.push(""); // Add spacing after table
+		if (nextTokenType && nextTokenType !== "space") {
+			lines.push(""); // Add spacing after table
+		}
 		return lines;
 	}
 }