@visual-z/xeno 0.1.4 → 0.2.0

package/src/vendor/pi-tui/utils.ts

@@ -180,8 +180,10 @@ function finalizeTruncatedResult(
  * check to avoid running the RGI_Emoji regex unnecessarily.
  */
 function graphemeWidth(segment: string): number {
-	if (segment === "\t") {
-		return 3;
+	if (segment.length === 1) {
+		const code = segment.charCodeAt(0);
+		if (code >= 0x20 && code <= 0x7e) return 1;
+		if (code === 0x09) return 3;
 	}
 
 	// Some marks occupy cells even without a base character.
@@ -250,9 +252,11 @@ export function visibleWidth(str: string): number {
 		return 0;
 	}
 
-	// Fast path: pure ASCII printable
-	if (isPrintableAscii(str)) {
-		return str.length;
+	// Fast path: printable ASCII, tabs, and ANSI escape sequences. Styled lines take this path, so
+	// re-rendering after a theme change does not run grapheme segmentation on every line.
+	const asciiWidth = asciiVisibleWidth(str);
+	if (asciiWidth !== -1) {
+		return asciiWidth;
 	}
 
 	// Check cache
@@ -266,22 +270,25 @@ export function visibleWidth(str: string): number {
 	if (str.includes("\t")) {
 		clean = clean.replace(/\t/g, "   ");
 	}
-	if (clean.includes("\x1b")) {
+	let escapeIndex = clean.indexOf("\x1b");
+	if (escapeIndex !== -1) {
 		// Strip supported ANSI/OSC/APC escape sequences in one pass.
 		// This covers CSI styling/cursor codes, OSC hyperlinks and prompt markers,
 		// and APC sequences like CURSOR_MARKER.
 		let stripped = "";
-		let i = 0;
-		while (i < clean.length) {
-			const ansi = extractAnsiCode(clean, i);
-			if (ansi) {
-				i += ansi.length;
-				continue;
+		let copyFrom = 0;
+		while (escapeIndex !== -1) {
+			const length = ansiCodeLength(clean, escapeIndex);
+			if (length > 0) {
+				stripped += clean.slice(copyFrom, escapeIndex);
+				escapeIndex += length;
+				copyFrom = escapeIndex;
+			} else {
+				escapeIndex++;
 			}
-			stripped += clean[i];
-			i++;
+			escapeIndex = clean.indexOf("\x1b", escapeIndex);
 		}
-		clean = stripped;
+		clean = stripped + clean.slice(copyFrom);
 	}
 
 	// Calculate width
@@ -412,43 +419,66 @@ export function normalizeTerminalOutput(str: string): string {
  * Extract ANSI escape sequences from a string at the given position.
  */
 export function extractAnsiCode(str: string, pos: number): { code: string; length: number } | null {
-	if (pos >= str.length || str[pos] !== "\x1b") return null;
+	const length = ansiCodeLength(str, pos);
+	return length > 0 ? { code: str.substring(pos, pos + length), length } : null;
+}
+
+/**
+ * Width of a string made of printable ASCII, tabs, and ANSI escape sequences, or -1 if it contains
+ * anything else. Matches `visibleWidth` for those strings without allocating.
+ */
+function asciiVisibleWidth(str: string): number {
+	let width = 0;
+	let i = 0;
+	while (i < str.length) {
+		const code = str.charCodeAt(i);
+		if (code >= 0x20 && code <= 0x7e) {
+			width++;
+			i++;
+		} else if (code === 0x09) {
+			width += 3;
+			i++;
+		} else if (code === 0x1b) {
+			const length = ansiCodeLength(str, i);
+			if (length === 0) return -1;
+			i += length;
+		} else {
+			return -1;
+		}
+	}
+	return width;
+}
+
+/** Length of the ANSI/OSC/APC escape sequence starting at `pos`, or 0 if there is none. */
+function ansiCodeLength(str: string, pos: number): number {
+	if (pos >= str.length || str.charCodeAt(pos) !== 0x1b) return 0;
 
 	const next = str[pos + 1];
 
 	// CSI sequence: ESC [ ... m/G/K/H/J
 	if (next === "[") {
-		let j = pos + 2;
-		while (j < str.length && !/[mGKHJ]/.test(str[j]!)) j++;
-		if (j < str.length) return { code: str.substring(pos, j + 1), length: j + 1 - pos };
-		return null;
+		for (let j = pos + 2; j < str.length; j++) {
+			const c = str.charCodeAt(j);
+			// m, G, K, H, J
+			if (c === 0x6d || c === 0x47 || c === 0x4b || c === 0x48 || c === 0x4a) return j + 1 - pos;
+		}
+		return 0;
 	}
 
 	// OSC sequence: ESC ] ... BEL or ESC ] ... ST (ESC \)
 	// Used for hyperlinks (OSC 8), window titles, etc.
-	if (next === "]") {
-		let j = pos + 2;
-		while (j < str.length) {
-			if (str[j] === "\x07") return { code: str.substring(pos, j + 1), length: j + 1 - pos };
-			if (str[j] === "\x1b" && str[j + 1] === "\\") return { code: str.substring(pos, j + 2), length: j + 2 - pos };
-			j++;
-		}
-		return null;
-	}
-
 	// APC sequence: ESC _ ... BEL or ESC _ ... ST (ESC \)
 	// Used for cursor marker and application-specific commands
-	if (next === "_") {
-		let j = pos + 2;
-		while (j < str.length) {
-			if (str[j] === "\x07") return { code: str.substring(pos, j + 1), length: j + 1 - pos };
-			if (str[j] === "\x1b" && str[j + 1] === "\\") return { code: str.substring(pos, j + 2), length: j + 2 - pos };
-			j++;
+	if (next === "]" || next === "_") {
+		for (let j = pos + 2; j < str.length; j++) {
+			const c = str.charCodeAt(j);
+			if (c === 0x07) return j + 1 - pos;
+			if (c === 0x1b && str[j + 1] === "\\") return j + 2 - pos;
 		}
-		return null;
+		return 0;
 	}
 
-	return null;
+	return 0;
 }
 
 type Osc8Terminator = "\x07" | "\x1b\\";
@@ -739,15 +769,16 @@ class AnsiCodeTracker {
 }
 
 function updateTrackerFromText(text: string, tracker: AnsiCodeTracker): void {
-	let i = 0;
-	while (i < text.length) {
-		const ansiResult = extractAnsiCode(text, i);
-		if (ansiResult) {
-			tracker.process(ansiResult.code);
-			i += ansiResult.length;
+	let i = text.indexOf("\x1b");
+	while (i !== -1) {
+		const length = ansiCodeLength(text, i);
+		if (length > 0) {
+			tracker.process(text.substring(i, i + length));
+			i += length;
 		} else {
 			i++;
 		}
+		i = text.indexOf("\x1b", i);
 	}
 }
 
@@ -758,6 +789,10 @@ export function getActiveBackgroundAnsi(text: string): string {
 	return tracker.getActiveBackgroundCode();
 }
 
+function* graphemeSegments(text: string): Generator<string> {
+	for (const { segment } of graphemeSegmenter.segment(text)) yield segment;
+}
+
 /**
  * Split text into words while keeping ANSI codes attached.
  */
@@ -786,14 +821,19 @@ function splitIntoTokensWithAnsi(text: string): string[] {
 			continue;
 		}
 
-		let end = i;
-		while (end < text.length && !extractAnsiCode(text, end)) {
-			end++;
+		// Visible text runs up to the next escape sequence.
+		let end = text.indexOf("\x1b", i + 1);
+		while (end !== -1 && ansiCodeLength(text, end) === 0) {
+			end = text.indexOf("\x1b", end + 1);
 		}
+		if (end === -1) end = text.length;
 
-		for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+		const chunk = text.slice(i, end);
+		// Printable ASCII characters are single graphemes, so skip the segmenter for them.
+		const ascii = isPrintableAscii(chunk);
+		for (const segment of ascii ? chunk : graphemeSegments(chunk)) {
 			const segmentIsSpace = segment === " ";
-			if (!segmentIsSpace && cjkBreakRegex.test(segment)) {
+			if (!ascii && !segmentIsSpace && cjkBreakRegex.test(segment)) {
 				flushCurrent();
 				const token = pendingAnsi + segment;
 				pendingAnsi = "";

package/src/vendor/pi-tui/wheel-scroll.ts

@@ -0,0 +1,82 @@
+/** Lines moved per mouse-wheel event, or `"auto"` to accelerate fast wheel spins. */
+export type WheelScrollLines = number | "auto";
+
+// Several events closer than this belong to one physical notch (Ghostty emits them ~4 ms apart)
+// or come from a high-resolution source. They move one line each and do not accelerate.
+const BURST_GAP_MS = 5;
+// A pause longer than this ends a scroll gesture.
+const GESTURE_GAP_MS = 200;
+// Average event gap that maps to one line per event. Faster events scale up proportionally.
+const REFERENCE_GAP_MS = 100;
+const MAX_AUTO_LINES = 6;
+
+/**
+ * Local macOS terminals receive wheel and trackpad deltas that the OS has already accelerated,
+ * and they emit one event per line. Other platforms, and SSH sessions where the client platform
+ * is unknown, usually send one event per wheel notch.
+ */
+function terminalAcceleratesWheel(): boolean {
+	const env = process.env;
+	return (
+		process.platform === "darwin" &&
+		env.SSH_CONNECTION === undefined &&
+		env.SSH_CLIENT === undefined &&
+		env.SSH_TTY === undefined
+	);
+}
+
+/**
+ * Converts wheel events into line counts.
+ *
+ * In `"auto"` mode on terminals that do not accelerate wheel input, the count follows event
+ * velocity: an isolated notch moves one line, while a fast spin moves up to six lines per event.
+ * For example, notches 100 ms apart move 1 line each, 50 ms apart move 2, and 20 ms apart move 5.
+ */
+export class WheelScrollAccelerator {
+	private lines: WheelScrollLines;
+	private readonly accelerate: boolean;
+	private lastTime = Number.NEGATIVE_INFINITY;
+	private lastDirection = 0;
+	private averageGap: number | undefined;
+	private carry = 0;
+
+	constructor(lines: WheelScrollLines = "auto", accelerate = !terminalAcceleratesWheel()) {
+		this.lines = lines;
+		this.accelerate = accelerate;
+	}
+
+	setLines(lines: WheelScrollLines): void {
+		this.lines = lines;
+		this.reset();
+	}
+
+	/** Return the positive line count for a wheel event in `direction` at time `now` (milliseconds). */
+	next(direction: -1 | 1, now: number): number {
+		if (this.lines !== "auto") return Number.isFinite(this.lines) ? Math.max(1, Math.floor(this.lines)) : 1;
+		if (!this.accelerate) return 1;
+
+		const gap = now - this.lastTime;
+		const sameGesture = direction === this.lastDirection && gap <= GESTURE_GAP_MS;
+		this.lastTime = now;
+		this.lastDirection = direction;
+		if (!sameGesture) {
+			this.averageGap = undefined;
+			this.carry = 0;
+			return 1;
+		}
+		if (gap < BURST_GAP_MS) return 1;
+
+		this.averageGap = this.averageGap === undefined ? gap : (this.averageGap + gap) / 2;
+		const lines = Math.min(MAX_AUTO_LINES, Math.max(1, REFERENCE_GAP_MS / this.averageGap)) + this.carry;
+		const whole = Math.floor(lines);
+		this.carry = lines - whole;
+		return whole;
+	}
+
+	private reset(): void {
+		this.lastTime = Number.NEGATIVE_INFINITY;
+		this.lastDirection = 0;
+		this.averageGap = undefined;
+		this.carry = 0;
+	}
+}