@linxiraos/pi-tui 1.1.26 → 1.2.0

package/src/windows-input-mode.ts

@@ -16,6 +16,12 @@
  * terminal sends; chords legacy encoding loses (modified Enter/Tab/Escape,
  * Ctrl+Shift+letter, …) translate to kitty CSI-u, which key matching already
  * parses.
+ *
+ * A host terminal that writes VT instead of key records (any ConPTY host
+ * besides Windows Terminal's native path) reaches us as one `Vk = 0` text
+ * record per byte: Alt+Up arrives as `ESC`, `[`, `1`, `;`, `3`, `A`. Those
+ * bytes are reassembled into the escape sequence they spell; delivering them
+ * one at a time turns every such key into a bare Escape plus typed garbage.
  */
 
 const W32IM_PATTERN = /^\x1b\[([\d;]*)_$/;
@@ -35,6 +41,9 @@ const VK_ESCAPE = 0x1b;
 const VK_SPACE = 0x20;
 const VK_PACKET = 0xe7;
 
+/** Keys encoded as fixed bytes that can still carry text a pending dead key composed. */
+const COMPOSABLE_FIXED_VKS = new Set([VK_BACK, VK_TAB, VK_RETURN, VK_ESCAPE, VK_SPACE]);
+
 /** Modifier and lock keys: their own presses produce no input. */
 const MODIFIER_VKS = new Set([
 	0x10, // VK_SHIFT
@@ -111,6 +120,31 @@ function baseCodepointForVk(vk: number): number {
 	return 0;
 }
 
+/** `split`: the leading ESC is a standalone Escape and the rest starts a new sequence. */
+type VtState = "partial" | "complete" | "invalid" | "split";
+
+/** Classify relayed VT text that starts with ESC. */
+function vtState(text: string): VtState {
+	if (text.length === 1) return "partial";
+	const introducer = text[1]!;
+	if (introducer === "\x1b") {
+		if (text.length === 2) return "partial";
+		// Only meta-CSI/SS3 (legacy Alt+Up is `ESC ESC [ A`) stays grouped; `ESC ESC d`
+		// is Escape followed by Alt+d, matching StdinBuffer.
+		return text[2] === "[" || text[2] === "O" ? vtState(text.slice(1)) : "split";
+	}
+	if (introducer === "[") {
+		if (/^\x1b\[[0-?]*[ -/]*[@-~]$/.test(text)) return "complete";
+		return /^\x1b\[[0-?]*[ -/]*$/.test(text) ? "partial" : "invalid";
+	}
+	if (introducer === "O") return text.length === 2 ? "partial" : text.length === 3 ? "complete" : "invalid";
+	if (introducer === "]" || introducer === "P" || introducer === "_") {
+		return text.endsWith("\x07") || (text.length > 3 && text.endsWith("\x1b\\")) ? "complete" : "partial";
+	}
+	// ESC + one character: Alt+character.
+	return text.length === 2 ? "complete" : "invalid";
+}
+
 function encodeKey(record: KeyRecord): string | null {
 	const { vk, uc, state } = record;
 	const shift = (state & SHIFT_PRESSED) !== 0;
@@ -119,6 +153,11 @@ function encodeKey(record: KeyRecord): string | null {
 	const mod = 1 + (shift ? 1 : 0) + (alt ? 2 : 0) + (ctrl ? 4 : 0);
 	const text = uc === 0 ? "" : String.fromCharCode(uc);
 
+	// A pending dead key composes onto the next key: on US-International, `'` then
+	// Space arrives as a Space record carrying `'`, and `'` then Enter as an Enter
+	// record carrying `'` followed by one carrying `\r`. The carried text is the input.
+	if (!ctrl && !alt && uc > 0x20 && uc !== 0x7f && COMPOSABLE_FIXED_VKS.has(vk)) return text;
+
 	switch (vk) {
 		case VK_RETURN:
 			return mod === 1 ? "\r" : `\x1b[13;${mod}u`;
@@ -165,9 +204,30 @@ function encodeKey(record: KeyRecord): string | null {
 	return uc === 0 ? null : text;
 }
 
-/** Stateful decoder: joins UTF-16 surrogate halves that arrive as separate records. */
+/**
+ * Stateful decoder: joins UTF-16 surrogate halves that arrive as separate
+ * records, and reassembles VT escape sequences relayed as text records.
+ */
 export class Win32InputModeDecoder {
 	#pendingHighSurrogate = 0;
+	/** Relayed VT text that starts with ESC and has not completed a sequence yet. */
+	#pendingVt = "";
+
+	/** Whether relayed VT text is held waiting for the rest of its sequence. */
+	get hasPendingSequence(): boolean {
+		return this.#pendingVt.length > 0;
+	}
+
+	/**
+	 * Release held VT text as-is. The caller invokes this once no further bytes
+	 * arrived in time, so a lone relayed ESC still acts as the Escape key.
+	 */
+	flushPendingSequence(): string[] {
+		if (this.#pendingVt.length === 0) return [];
+		const pending = this.#pendingVt;
+		this.#pendingVt = "";
+		return [pending];
+	}
 
 	/**
 	 * Translate one stdin sequence. Returns `undefined` when `data` is not a
@@ -180,17 +240,42 @@ export class Win32InputModeDecoder {
 
 		if (!record.down) {
 			// Alt+Numpad composition delivers its character on the Alt release.
-			if (record.vk === VK_MENU && record.uc !== 0) return this.#emitText(record.uc);
+			if (record.vk === VK_MENU && record.uc !== 0) return this.#assembleVt(this.#emitText(record.uc));
 			return [];
 		}
 		if (MODIFIER_VKS.has(record.vk)) return [];
-		if (record.vk === 0 || record.vk === VK_PACKET) return this.#emitText(record.uc, record.repeat);
-		if (record.uc >= 0xd800 && record.uc <= 0xdfff) return this.#emitText(record.uc);
+		if (record.vk === 0 || record.vk === VK_PACKET) return this.#assembleVt(this.#emitText(record.uc, record.repeat));
+		if (record.uc >= 0xd800 && record.uc <= 0xdfff) return this.#assembleVt(this.#emitText(record.uc));
 
 		this.#pendingHighSurrogate = 0;
 		const encoded = encodeKey(record);
-		if (encoded === null) return [];
-		return Array.from({ length: record.repeat }, () => encoded);
+		// A real key ends whatever relayed text was still incomplete.
+		const flushed = this.flushPendingSequence();
+		if (encoded === null) return flushed;
+		for (let i = 0; i < record.repeat; i++) flushed.push(encoded);
+		return flushed;
+	}
+
+	/** Group relayed text into whole escape sequences; other text passes through per character. */
+	#assembleVt(texts: string[]): string[] {
+		const out: string[] = [];
+		for (const text of texts) {
+			if (this.#pendingVt.length === 0 && text !== "\x1b") {
+				out.push(text);
+				continue;
+			}
+			this.#pendingVt += text;
+			let state = vtState(this.#pendingVt);
+			while (state === "split") {
+				out.push("\x1b");
+				this.#pendingVt = this.#pendingVt.slice(1);
+				state = vtState(this.#pendingVt);
+			}
+			if (state === "partial") continue;
+			out.push(this.#pendingVt);
+			this.#pendingVt = "";
+		}
+		return out;
 	}
 
 	/**
@@ -228,3 +313,124 @@ export class Win32InputModeDecoder {
 		return Array.from({ length: repeat }, () => text);
 	}
 }
+
+const RECORD_AT_START = /^\x1b\[[\d;]*_/;
+const RECORD_PREFIX = /^\x1b\[[\d;]*$/;
+const MAX_RECORD_LENGTH = 64;
+
+/**
+ * Restores paste delimiters that a Windows console host emitted as individual
+ * win32-input-mode key records before StdinBuffer searches for the delimiters.
+ * Non-matching records remain untouched for normal key and paste decoding.
+ */
+export class Win32PasteMarkerNormalizer {
+	#pending = "";
+	#candidate = "";
+	#index = 0;
+	#marker = "";
+	#timer?: NodeJS.Timeout;
+	readonly #onInput: (data: string) => void;
+	readonly #onExpired?: () => void;
+
+	/**
+	 * `onExpired` runs after held records are released because their wait timed
+	 * out, so a downstream holder can treat the same wait as already elapsed.
+	 */
+	constructor(onInput: (data: string) => void, onExpired?: () => void) {
+		this.#onInput = onInput;
+		this.#onExpired = onExpired;
+	}
+
+	process(data: string): void {
+		if (!this.#pending && !this.#candidate && !data.includes("\x1b")) {
+			this.#onInput(data);
+			return;
+		}
+		clearTimeout(this.#timer);
+		this.#timer = undefined;
+		this.#pending += data;
+		let output = "";
+
+		while (this.#pending.length > 0) {
+			const escape = this.#pending.indexOf("\x1b");
+			if (escape > 0) {
+				output += this.#candidate + this.#pending.slice(0, escape);
+				this.#candidate = "";
+				this.#index = 0;
+				this.#pending = this.#pending.slice(escape);
+			} else if (escape === -1) {
+				output += this.#candidate + this.#pending;
+				this.#candidate = "";
+				this.#index = 0;
+				this.#pending = "";
+				break;
+			}
+
+			if (this.#pending.length === 1) break;
+			if (this.#pending[1] !== "[") {
+				output += this.#candidate + this.#pending[0];
+				this.#candidate = "";
+				this.#index = 0;
+				this.#pending = this.#pending.slice(1);
+				continue;
+			}
+			const record = RECORD_AT_START.exec(this.#pending)?.[0];
+			if (!record) {
+				if (this.#pending.length <= MAX_RECORD_LENGTH && RECORD_PREFIX.test(this.#pending)) break;
+				output += this.#candidate + this.#pending[0];
+				this.#candidate = "";
+				this.#index = 0;
+				this.#pending = this.#pending.slice(1);
+				continue;
+			}
+
+			this.#pending = this.#pending.slice(record.length);
+			const key = parseRecord(record);
+			if (this.#candidate && key && !key.down) {
+				this.#candidate += record;
+				continue;
+			}
+			if (key?.down && key.state === 0 && key.repeat === 1) {
+				const expected = this.#index === 0 ? 27 : "[200~".charCodeAt(this.#index - 1);
+				if (key.uc === expected || (this.#index === 4 && key.uc === 49)) {
+					if (this.#index === 4) this.#marker = String.fromCharCode(key.uc);
+					this.#candidate += record;
+					if (++this.#index === 6) {
+						output += `\x1b[20${this.#marker}~`;
+						this.#candidate = "";
+						this.#index = 0;
+					}
+					continue;
+				}
+			}
+			output += this.#candidate;
+			this.#candidate = "";
+			this.#index = 0;
+			if (key?.down && key.state === 0 && key.repeat === 1 && key.uc === 27) {
+				this.#candidate = record;
+				this.#index = 1;
+			} else {
+				output += record;
+			}
+		}
+
+		if (output) this.#onInput(output);
+		if (this.#candidate || this.#pending) {
+			this.#timer = setTimeout(() => {
+				this.flush();
+				this.#onExpired?.();
+			}, 75);
+		}
+	}
+
+	/** Release an incomplete marker as its original key records. */
+	flush(): void {
+		clearTimeout(this.#timer);
+		this.#timer = undefined;
+		const raw = this.#candidate + this.#pending;
+		this.#candidate = "";
+		this.#pending = "";
+		this.#index = 0;
+		if (raw) this.#onInput(raw);
+	}
+}