@effect-tui/react 0.15.2 → 0.16.0

package/src/utils/alignment.ts

@@ -4,7 +4,7 @@
 
 import type { Rect, Size } from "../reconciler/types.js"
 
-export type HAlign = "left" | "center" | "right" | "leading" | "trailing"
+export type HAlign = "left" | "center" | "right"
 export type VAlign = "top" | "center" | "bottom"
 
 /**
@@ -22,14 +22,12 @@ export function alignInRect(
 
 	switch (hAlign) {
 		case "left":
-		case "leading":
 			x = rect.x
 			break
 		case "center":
 			x = rect.x + Math.floor((rect.w - size.w) / 2)
 			break
 		case "right":
-		case "trailing":
 			x = rect.x + Math.max(0, rect.w - size.w)
 			break
 	}

package/src/utils/console-helpers.ts

@@ -0,0 +1,86 @@
+export interface SelectionPoint {
+	line: number
+	col: number
+}
+
+export function formatTimestamp(date: Date): string {
+	const h = date.getHours().toString().padStart(2, "0")
+	const m = date.getMinutes().toString().padStart(2, "0")
+	const s = date.getSeconds().toString().padStart(2, "0")
+	return `${h}:${m}:${s}`
+}
+
+export function formatLocation(loc?: { file: string; line: number }): string {
+	if (!loc) return ""
+	const parts = loc.file.split("/")
+	const filename = parts[parts.length - 1]
+	return `${filename}:${loc.line}`
+}
+
+export function wrapLine(text: string, maxWidth: number): string[] {
+	if (text.length <= maxWidth) return [text]
+
+	const lines: string[] = []
+	let remaining = text
+
+	while (remaining.length > 0) {
+		if (remaining.length <= maxWidth) {
+			lines.push(remaining)
+			break
+		}
+
+		let breakAt = maxWidth
+		const lastSpace = remaining.lastIndexOf(" ", maxWidth)
+		if (lastSpace > maxWidth * 0.5) {
+			breakAt = lastSpace
+		}
+
+		lines.push(remaining.slice(0, breakAt))
+		remaining = remaining.slice(breakAt).trimStart()
+	}
+
+	return lines
+}
+
+/** Normalize selection so start is before end */
+export function normalizeSelection(
+	anchor: SelectionPoint,
+	head: SelectionPoint,
+): [SelectionPoint, SelectionPoint] {
+	if (anchor.line < head.line || (anchor.line === head.line && anchor.col <= head.col)) {
+		return [anchor, head]
+	}
+	return [head, anchor]
+}
+
+/** Get selection bounds for a specific line */
+export function getLineSelection(
+	lineIndex: number,
+	lineLength: number,
+	start: SelectionPoint,
+	end: SelectionPoint,
+): { startCol: number; endCol: number } | null {
+	if (lineIndex < start.line || lineIndex > end.line) return null
+
+	const startCol = lineIndex === start.line ? Math.min(start.col, lineLength) : 0
+	const endCol = lineIndex === end.line ? Math.min(end.col, lineLength) : lineLength
+
+	if (startCol >= endCol && lineIndex === start.line && lineIndex === end.line) return null
+
+	return { startCol, endCol }
+}
+
+export function getSelectionText(
+	lines: string[],
+	start: SelectionPoint,
+	end: SelectionPoint,
+): string {
+	const selected: string[] = []
+	for (let i = start.line; i <= end.line && i < lines.length; i++) {
+		const lineText = lines[i] ?? ""
+		const startCol = i === start.line ? Math.min(start.col, lineText.length) : 0
+		const endCol = i === end.line ? Math.min(end.col, lineText.length) : lineText.length
+		selected.push(lineText.slice(startCol, endCol))
+	}
+	return selected.join("\n")
+}

package/src/utils/index.ts

@@ -20,5 +20,5 @@ export {
 	styleSpecFromProps,
 	toColorValue,
 } from "./styles.js"
-export { wrapSpans } from "./text-wrap.js"
+export { wrapSpans, wrapText } from "./text-wrap.js"
 export { isWhitespace, matchNextWord, matchPrevWord, splitWords } from "./word-boundaries.js"

package/src/utils/styles.ts

@@ -83,14 +83,26 @@ export function resolveInheritedBgStyle(
 /**
  * Fill a rect with background color, inheriting from parent if needed.
  */
+export interface FillRectWithInheritedBgOptions {
+	/** Skip filling when there is no inherited background value. */
+	skipWhenUndefined?: boolean
+}
+
 export function fillRectWithInheritedBg(
 	buffer: CellBuffer,
 	palette: Palette,
 	rect: Rect,
 	explicitBg: Color | undefined,
 	parent: HostInstance | null,
-): void {
-	if (rect.w <= 0 || rect.h <= 0) return
-	const { styleId } = resolveInheritedBgStyle(palette, explicitBg, parent)
-	buffer.fillRect(rect.x, rect.y, rect.w, rect.h, " ".codePointAt(0)!, styleId)
+	options?: FillRectWithInheritedBgOptions,
+): { value?: ColorValue; styleId: number } {
+	if (rect.w <= 0 || rect.h <= 0) {
+		return { value: undefined, styleId: 0 }
+	}
+	const resolved = resolveInheritedBgStyle(palette, explicitBg, parent)
+	if (options?.skipWhenUndefined && resolved.value === undefined) {
+		return resolved
+	}
+	buffer.fillRect(rect.x, rect.y, rect.w, rect.h, " ".codePointAt(0)!, resolved.styleId)
+	return resolved
 }

package/src/utils/text-wrap.ts

@@ -3,59 +3,99 @@ import { isWhitespace, splitWords } from "./word-boundaries.js"
 
 type SpanLike = { text: string }
 
-/**
- * Wrap spans into lines, breaking at word boundaries.
- * Preserves span styling by cloning span objects with updated text.
- */
-export function wrapSpans<T extends SpanLike>(spans: T[], maxWidth: number): T[][] {
-	const lines: T[][] = [[]]
+type TokenSpec<T> = {
+	text: string
+	width: number
+	isWhitespace: boolean
+	make: (text: string) => T
+}
+
+type LineToken<T> = {
+	value: T
+	width: number
+	isWhitespace: boolean
+}
+
+type WrapOptions = {
+	trimTrailingWhitespace?: boolean
+}
+
+function wrapTokens<T>(tokens: TokenSpec<T>[], maxWidth: number, options?: WrapOptions): T[][] {
+	const lines: LineToken<T>[][] = [[]]
 	let lineWidth = 0
 
-	for (const span of spans) {
-		// Split span text into words (keeping whitespace as separate tokens)
-		const tokens = splitWords(span.text)
+	const trimLine = () => {
+		if (!options?.trimTrailingWhitespace) return
+		const line = lines[lines.length - 1]
+		while (line.length > 0 && line[line.length - 1].isWhitespace) {
+			const removed = line.pop()
+			if (removed) {
+				lineWidth -= removed.width
+			}
+		}
+	}
 
-		for (const token of tokens) {
-			if (!token) continue
-			const tokenWidth = displayWidth(token)
-			const isWs = isWhitespace(token)
-
-			if (lineWidth + tokenWidth <= maxWidth) {
-				// Token fits on current line
-				lines[lines.length - 1].push({ ...span, text: token })
-				lineWidth += tokenWidth
-			} else if (isWs) {
-				// Skip whitespace at line break
-				continue
-			} else if (tokenWidth <= maxWidth) {
-				// Start new line with this token
-				lines.push([{ ...span, text: token }])
-				lineWidth = tokenWidth
-			} else {
-				// Token is longer than maxWidth - break by character
-				let charLine = ""
-				let charLineWidth = 0
-				for (const ch of token) {
-					const chWidth = displayWidth(ch)
-					if (lineWidth + charLineWidth + chWidth > maxWidth && (charLine || lineWidth > 0)) {
-						if (charLine) {
-							lines[lines.length - 1].push({ ...span, text: charLine })
-						}
-						lines.push([])
-						lineWidth = 0
-						charLine = ch
-						charLineWidth = chWidth
-					} else {
-						charLine += ch
-						charLineWidth += chWidth
-					}
-				}
-				if (charLine) {
-					lines[lines.length - 1].push({ ...span, text: charLine })
-					lineWidth += charLineWidth
+	const startNewLine = () => {
+		lines.push([])
+		lineWidth = 0
+	}
+
+	const addToken = (token: TokenSpec<T>, text: string, width: number, isWhitespace: boolean) => {
+		lines[lines.length - 1].push({ value: token.make(text), width, isWhitespace })
+		lineWidth += width
+	}
+
+	for (const token of tokens) {
+		if (!token.text) continue
+		const tokenWidth = token.width
+		const isWs = token.isWhitespace
+
+		if (lineWidth + tokenWidth <= maxWidth) {
+			addToken(token, token.text, tokenWidth, isWs)
+			continue
+		}
+
+		if (isWs) {
+			// Skip whitespace at line break
+			continue
+		}
+
+		if (tokenWidth <= maxWidth) {
+			trimLine()
+			if (lines[lines.length - 1].length > 0) {
+				startNewLine()
+			}
+			addToken(token, token.text, tokenWidth, isWs)
+			continue
+		}
+
+		// Token is longer than maxWidth - break by character
+		trimLine()
+		if (lines[lines.length - 1].length > 0) {
+			startNewLine()
+		}
+
+		let segment = ""
+		let segmentWidth = 0
+
+		for (const ch of token.text) {
+			const chWidth = displayWidth(ch)
+			if (lineWidth + segmentWidth + chWidth > maxWidth && (segment || lineWidth > 0)) {
+				if (segment) {
+					addToken(token, segment, segmentWidth, false)
 				}
+				startNewLine()
+				segment = ch
+				segmentWidth = chWidth
+			} else {
+				segment += ch
+				segmentWidth += chWidth
 			}
 		}
+
+		if (segment) {
+			addToken(token, segment, segmentWidth, false)
+		}
 	}
 
 	// Remove empty lines at the end
@@ -63,5 +103,56 @@ export function wrapSpans<T extends SpanLike>(spans: T[], maxWidth: number): T[]
 		lines.pop()
 	}
 
-	return lines.length > 0 ? lines : [[]]
+	return lines.length > 0 ? lines.map((line) => line.map((token) => token.value)) : [[]]
+}
+
+/**
+ * Wrap spans into lines, breaking at word boundaries.
+ * Preserves span styling by cloning span objects with updated text.
+ */
+export function wrapSpans<T extends SpanLike>(spans: T[], maxWidth: number): T[][] {
+	const tokens: Array<TokenSpec<T>> = []
+	for (const span of spans) {
+		for (const token of splitWords(span.text)) {
+			if (!token) continue
+			tokens.push({
+				text: token,
+				width: displayWidth(token),
+				isWhitespace: isWhitespace(token),
+				make: (text) => ({ ...span, text }),
+			})
+		}
+	}
+
+	return wrapTokens(tokens, maxWidth)
+}
+
+/**
+ * Wrap plain text into lines, breaking at word boundaries.
+ * Trims trailing whitespace when a line breaks.
+ */
+export function wrapText(text: string, maxWidth: number): string[] {
+	const lines: string[] = []
+	for (const rawLine of text.split("\n")) {
+		if (rawLine === "") {
+			lines.push("")
+			continue
+		}
+		const tokens: Array<TokenSpec<string>> = []
+		for (const token of splitWords(rawLine)) {
+			if (!token) continue
+			tokens.push({
+				text: token,
+				width: displayWidth(token),
+				isWhitespace: isWhitespace(token),
+				make: (segment) => segment,
+			})
+		}
+		const wrapped = wrapTokens(tokens, maxWidth, { trimTrailingWhitespace: true })
+		for (const line of wrapped) {
+			lines.push(line.join(""))
+		}
+	}
+
+	return lines.length > 0 ? lines : [""]
 }

package/src/visualize/index.tsx

@@ -273,7 +273,7 @@ export const visualize = <A, E, R>(
 				: { status: "failure", elapsedMs: Date.now() - startTime, errorSummary: summarizeCause(exit.cause) },
 		)
 		renderer.requestRender()
-		renderer.flush() // Ensure final state is rendered
+		renderer.renderNow() // Ensure final state is rendered
 
 		// Wait for completion animation
 		yield* Effect.sleep(COMPLETION_DELAY_MS)

package/src/renderer/lifecycle/ResizeManager.ts

@@ -1,65 +0,0 @@
-import type { TuiWriteStream } from "../../renderer-types.js"
-
-export interface ResizeState {
-	width: number
-	height: number
-	lastWidth: number
-	previousHeight: number // For inline mode
-	inlineClearHeight: number
-}
-
-export interface ResizeResult {
-	newWidth: number
-	newHeight: number
-	needsFullClear: boolean // Fullscreen mode
-	inlineClearHeight: number // Inline mode
-}
-
-/**
- * Handles terminal resize events and calculates necessary clear/redraw actions.
- */
-export class ResizeManager {
-	constructor(
-		private stdout: TuiWriteStream,
-		private mode: "fullscreen" | "inline",
-	) {}
-
-	/**
-	 * Process a resize event and determine what actions are needed.
-	 */
-	handleResize(currentState: ResizeState): ResizeResult {
-		const newWidth = this.stdout.columns || 80
-		const newHeight = this.stdout.rows || 24
-
-		let needsFullClear = false
-		let inlineClearHeight = currentState.inlineClearHeight
-
-		if (this.mode === "fullscreen") {
-			// Fullscreen: defer clear to renderFrame so it's written atomically with content
-			needsFullClear = true
-		} else if (newWidth !== currentState.lastWidth || newHeight !== currentState.height) {
-			// Inline: on dimension change, request clear on next render
-			const clearHeight = Math.max(currentState.previousHeight, currentState.height, newHeight)
-			if (clearHeight > inlineClearHeight) {
-				inlineClearHeight = clearHeight
-			}
-		}
-
-		return {
-			newWidth,
-			newHeight,
-			needsFullClear,
-			inlineClearHeight,
-		}
-	}
-
-	/**
-	 * Get current terminal dimensions.
-	 */
-	getDimensions(): { width: number; height: number } {
-		return {
-			width: this.stdout.columns || 80,
-			height: this.stdout.rows || 24,
-		}
-	}
-}

package/src/renderer/lifecycle/index.ts

@@ -1,4 +0,0 @@
-export { EventBus } from "./EventBus.js"
-export { getRenderCache, type RenderCache } from "./RenderCache.js"
-export { ResizeManager, type ResizeResult, type ResizeState } from "./ResizeManager.js"
-export { TerminalSetup, type TerminalSetupConfig } from "./TerminalSetup.js"