@step-forge/step-forge 0.0.25-alpha.1 → 0.0.25-alpha.3

package/dist/cli.js

@@ -10,6 +10,7 @@ import * as fs from "node:fs";
 import { parseArgs } from "node:util";
 import { spawn } from "node:child_process";
 import * as readline from "node:readline";
+import { PassThrough } from "node:stream";
 //#region src/runtime/config.ts
 const DEFAULT_FEATURES = "**/*.feature";
 const DEFAULT_STEPS = "**/*.steps.ts";
@@ -526,9 +527,14 @@ var Prompt = class {
 	results = freshResults();
 	failScroll = 0;
 	started = false;
+	/** Filtered key stream: raw stdin minus the mouse sequences we handle. */
+	input;
 	keyListener;
+	dataListener;
 	resizeListener;
 	signalCleanup;
+	/** Carry an incomplete mouse sequence split across stdin chunks. */
+	mousePending = "";
 	constructor(options) {
 		this.handlers = options.handlers;
 		this.prefix = options.prefix ?? "› ";
@@ -583,11 +589,14 @@ var Prompt = class {
 	start() {
 		if (this.started) return;
 		this.started = true;
-		readline.emitKeypressEvents(process.stdin);
 		if (process.stdin.isTTY) process.stdin.setRawMode(true);
-		write("\x1B[?1049h");
+		write("\x1B[?1049h\x1B[?1000h\x1B[?1006h");
+		this.input = new PassThrough();
+		readline.emitKeypressEvents(this.input);
 		this.keyListener = (str, key) => this.onKey(str, key ?? {});
-		process.stdin.on("keypress", this.keyListener);
+		this.input.on("keypress", this.keyListener);
+		this.dataListener = (chunk) => this.onStdinData(chunk);
+		process.stdin.on("data", this.dataListener);
 		process.stdin.resume();
 		this.resizeListener = () => this.render();
 		process.stdout.on("resize", this.resizeListener);
@@ -598,11 +607,14 @@ var Prompt = class {
 	stop() {
 		if (!this.started) return;
 		this.started = false;
-		if (this.keyListener) process.stdin.off("keypress", this.keyListener);
+		if (this.dataListener) process.stdin.off("data", this.dataListener);
+		if (this.keyListener) this.input?.off("keypress", this.keyListener);
 		if (this.resizeListener) process.stdout.off("resize", this.resizeListener);
 		this.signalCleanup?.();
 		this.restoreTerminal();
 		process.stdin.pause();
+		this.input = void 0;
+		this.mousePending = "";
 	}
 	/** Force a repaint (after mutating `status`, say). No-op until started. */
 	redraw() {
@@ -615,6 +627,7 @@ var Prompt = class {
 	*/
 	restoreTerminal() {
 		if (process.stdin.isTTY) process.stdin.setRawMode(false);
+		write("\x1B[?1006l\x1B[?1000l");
 		write("\x1B[?25h");
 		write("\x1B[?1049l");
 	}
@@ -718,12 +731,72 @@ var Prompt = class {
 		this.reWindow();
 		this.render();
 	}
-	/** Scroll the failures pane by a page (clamped in {@link render}). */
+	/** Scroll the failures pane by whole pages (PgUp/PgDn). */
 	scrollFailures(pages) {
-		this.failScroll = Math.max(0, this.failScroll + pages * this.failPage);
-		this.render();
+		this.adjustFailScroll(pages * this.failPage);
 	}
 	failPage = 1;
+	/**
+	* Move the failures viewport by `deltaLines` (clamped in {@link render}).
+	* Scrolling repaints via {@link scheduleRender} so a burst of wheel events
+	* (a trackpad fires many per gesture) collapses into a single frame instead of
+	* one full-screen repaint each — which is what made small scrolls stutter.
+	*/
+	adjustFailScroll(deltaLines) {
+		this.failScroll = Math.max(0, this.failScroll + deltaLines);
+		this.scheduleRender();
+	}
+	renderQueued = false;
+	/** Coalesce repaints scheduled within the same tick into one frame. */
+	scheduleRender() {
+		if (this.renderQueued) return;
+		this.renderQueued = true;
+		queueMicrotask(() => {
+			this.renderQueued = false;
+			if (this.started) this.render();
+		});
+	}
+	/**
+	* Split a raw stdin chunk: decode SGR/legacy mouse sequences here (only the
+	* wheel is acted on — it scrolls the failures pane by a few lines) and forward
+	* everything else to readline. An incomplete trailing mouse sequence is held
+	* in {@link mousePending} for the next chunk. `latin1` keeps every byte 1:1 so
+	* the forwarded bytes reassemble exactly (including multibyte input).
+	*/
+	onStdinData(chunk) {
+		const buf = this.mousePending + chunk.toString("latin1");
+		let out = "";
+		let i = 0;
+		while (i < buf.length) {
+			if (buf.startsWith("\x1B[<", i)) {
+				const rel = /[Mm]/.exec(buf.slice(i + 3));
+				if (!rel) break;
+				const end = i + 3 + rel.index + 1;
+				this.handleMouse(buf.slice(i, end));
+				i = end;
+				continue;
+			}
+			if (buf.startsWith("\x1B[M", i)) {
+				if (i + 6 > buf.length) break;
+				this.handleMouse(buf.slice(i, i + 6));
+				i += 6;
+				continue;
+			}
+			out += buf[i];
+			i++;
+		}
+		this.mousePending = buf.slice(i);
+		if (out) this.input?.write(Buffer.from(out, "latin1"));
+	}
+	/** Act on a decoded mouse sequence — wheel up/down scrolls failures; else ignore. */
+	handleMouse(seq) {
+		let button = null;
+		const sgr = /^\x1b\[<(\d+);\d+;\d+[Mm]$/.exec(seq);
+		if (sgr) button = parseInt(sgr[1], 10);
+		else if (seq.length === 6) button = seq.charCodeAt(3) - 32;
+		if (button === null || (button & 64) === 0) return;
+		this.adjustFailScroll((button & 1) === 0 ? -1 : 1);
+	}
 	refilter() {
 		const q = this.query.trim().toLowerCase();
 		this.matches = this.all.map((s, index) => ({