@teammates/consolonia 0.7.1 → 0.7.2

package/dist/__tests__/ansi.test.js

@@ -4,6 +4,7 @@ import * as esc from "../ansi/esc.js";
 import { AnsiOutput } from "../ansi/output.js";
 import { stripAnsi, truncateAnsi, visibleLength } from "../ansi/strip.js";
 import { detectTerminal } from "../ansi/terminal-env.js";
+import { enableWin32Mouse, restoreWin32Console, } from "../ansi/win32-console.js";
 // ── Helpers ────────────────────────────────────────────────────────
 const ESC = "\x1b[";
 /** Build a mock writable stream that accumulates output to a string. */
@@ -534,7 +535,10 @@ describe("detectTerminal", () => {
         }
         Object.assign(process.env, origEnv);
         Object.defineProperty(process, "platform", { value: origPlatform });
-        Object.defineProperty(process.stdout, "isTTY", { value: origIsTTY, writable: true });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: origIsTTY,
+            writable: true,
+        });
     });
     function setEnv(overrides) {
         for (const [k, v] of Object.entries(overrides)) {
@@ -545,7 +549,10 @@ describe("detectTerminal", () => {
         }
     }
     it("returns pipe caps when stdout is not a TTY", () => {
-        Object.defineProperty(process.stdout, "isTTY", { value: false, writable: true });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: false,
+            writable: true,
+        });
         const caps = detectTerminal();
         expect(caps.isTTY).toBe(false);
         expect(caps.mouse).toBe(false);
@@ -554,7 +561,10 @@ describe("detectTerminal", () => {
     });
     it("detects Windows Terminal via WT_SESSION", () => {
         Object.defineProperty(process, "platform", { value: "win32" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
         setEnv({ WT_SESSION: "some-guid" });
         const caps = detectTerminal();
         expect(caps.name).toBe("windows-terminal");
@@ -563,7 +573,10 @@ describe("detectTerminal", () => {
     });
     it("detects VS Code terminal on Windows", () => {
         Object.defineProperty(process, "platform", { value: "win32" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
         setEnv({ WT_SESSION: undefined, TERM_PROGRAM: "vscode" });
         const caps = detectTerminal();
         expect(caps.name).toBe("vscode");
@@ -571,21 +584,40 @@ describe("detectTerminal", () => {
     });
     it("detects ConEmu on Windows", () => {
         Object.defineProperty(process, "platform", { value: "win32" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
-        setEnv({ WT_SESSION: undefined, TERM_PROGRAM: undefined, ConEmuPID: "1234" });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
+        setEnv({
+            WT_SESSION: undefined,
+            TERM_PROGRAM: undefined,
+            ConEmuPID: "1234",
+        });
         const caps = detectTerminal();
         expect(caps.name).toBe("conemu");
     });
     it("detects mintty via TERM + MSYSTEM", () => {
         Object.defineProperty(process, "platform", { value: "win32" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
-        setEnv({ WT_SESSION: undefined, TERM_PROGRAM: undefined, ConEmuPID: undefined, TERM: "xterm-256color", MSYSTEM: "MINGW64" });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
+        setEnv({
+            WT_SESSION: undefined,
+            TERM_PROGRAM: undefined,
+            ConEmuPID: undefined,
+            TERM: "xterm-256color",
+            MSYSTEM: "MINGW64",
+        });
         const caps = detectTerminal();
         expect(caps.name).toBe("mintty");
     });
     it("detects tmux on Unix", () => {
         Object.defineProperty(process, "platform", { value: "linux" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
         setEnv({ TMUX: "/tmp/tmux-1000/default,1234,0", TERM: "screen-256color" });
         const caps = detectTerminal();
         expect(caps.name).toBe("tmux");
@@ -593,8 +625,16 @@ describe("detectTerminal", () => {
     });
     it("detects GNU screen with limited caps", () => {
         Object.defineProperty(process, "platform", { value: "linux" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
-        setEnv({ TMUX: undefined, TERM: "screen", TERM_PROGRAM: undefined, ITERM_SESSION_ID: undefined });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
+        setEnv({
+            TMUX: undefined,
+            TERM: "screen",
+            TERM_PROGRAM: undefined,
+            ITERM_SESSION_ID: undefined,
+        });
         const caps = detectTerminal();
         expect(caps.name).toBe("screen");
         expect(caps.sgrMouse).toBe(false);
@@ -602,24 +642,48 @@ describe("detectTerminal", () => {
     });
     it("detects iTerm2", () => {
         Object.defineProperty(process, "platform", { value: "darwin" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
-        setEnv({ TMUX: undefined, TERM: "xterm-256color", TERM_PROGRAM: "iTerm.app" });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
+        setEnv({
+            TMUX: undefined,
+            TERM: "xterm-256color",
+            TERM_PROGRAM: "iTerm.app",
+        });
         const caps = detectTerminal();
         expect(caps.name).toBe("iterm2");
         expect(caps.truecolor).toBe(true);
     });
     it("detects xterm-compatible with COLORTERM truecolor", () => {
         Object.defineProperty(process, "platform", { value: "linux" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
-        setEnv({ TMUX: undefined, TERM: "xterm-256color", TERM_PROGRAM: undefined, ITERM_SESSION_ID: undefined, COLORTERM: "truecolor" });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
+        setEnv({
+            TMUX: undefined,
+            TERM: "xterm-256color",
+            TERM_PROGRAM: undefined,
+            ITERM_SESSION_ID: undefined,
+            COLORTERM: "truecolor",
+        });
         const caps = detectTerminal();
         expect(caps.truecolor).toBe(true);
         expect(caps.color256).toBe(true);
     });
     it("detects dumb terminal with minimal caps", () => {
         Object.defineProperty(process, "platform", { value: "linux" });
-        Object.defineProperty(process.stdout, "isTTY", { value: true, writable: true });
-        setEnv({ TMUX: undefined, TERM: "dumb", TERM_PROGRAM: undefined, ITERM_SESSION_ID: undefined });
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: true,
+            writable: true,
+        });
+        setEnv({
+            TMUX: undefined,
+            TERM: "dumb",
+            TERM_PROGRAM: undefined,
+            ITERM_SESSION_ID: undefined,
+        });
         const caps = detectTerminal();
         expect(caps.name).toBe("dumb");
         expect(caps.mouse).toBe(false);
@@ -667,7 +731,10 @@ describe("esc environment-aware sequences", () => {
     describe("initSequence", () => {
         it("includes all features for a full-caps terminal", () => {
             const caps = makeCaps();
-            const seq = esc.initSequence(caps, { alternateScreen: true, mouse: true });
+            const seq = esc.initSequence(caps, {
+                alternateScreen: true,
+                mouse: true,
+            });
             expect(seq).toContain(esc.alternateScreenOn);
             expect(seq).toContain(esc.hideCursor);
             expect(seq).toContain(esc.bracketedPasteOn);
@@ -676,34 +743,52 @@ describe("esc environment-aware sequences", () => {
         });
         it("skips alternate screen when not supported", () => {
             const caps = makeCaps({ alternateScreen: false });
-            const seq = esc.initSequence(caps, { alternateScreen: true, mouse: false });
+            const seq = esc.initSequence(caps, {
+                alternateScreen: true,
+                mouse: false,
+            });
             expect(seq).not.toContain(esc.alternateScreenOn);
         });
         it("skips alternate screen when app opts out", () => {
             const caps = makeCaps();
-            const seq = esc.initSequence(caps, { alternateScreen: false, mouse: false });
+            const seq = esc.initSequence(caps, {
+                alternateScreen: false,
+                mouse: false,
+            });
             expect(seq).not.toContain(esc.alternateScreenOn);
         });
         it("skips bracketed paste when not supported", () => {
             const caps = makeCaps({ bracketedPaste: false });
-            const seq = esc.initSequence(caps, { alternateScreen: false, mouse: false });
+            const seq = esc.initSequence(caps, {
+                alternateScreen: false,
+                mouse: false,
+            });
             expect(seq).not.toContain(esc.bracketedPasteOn);
         });
         it("skips mouse when app opts out even if caps support it", () => {
             const caps = makeCaps();
-            const seq = esc.initSequence(caps, { alternateScreen: false, mouse: false });
+            const seq = esc.initSequence(caps, {
+                alternateScreen: false,
+                mouse: false,
+            });
             expect(seq).not.toContain("?1000h");
         });
         it("returns empty string for non-TTY", () => {
             const caps = makeCaps({ isTTY: false });
-            const seq = esc.initSequence(caps, { alternateScreen: true, mouse: true });
+            const seq = esc.initSequence(caps, {
+                alternateScreen: true,
+                mouse: true,
+            });
             expect(seq).toBe("");
         });
     });
     describe("restoreSequence", () => {
         it("includes all restore features for a full-caps terminal", () => {
             const caps = makeCaps();
-            const seq = esc.restoreSequence(caps, { alternateScreen: true, mouse: true });
+            const seq = esc.restoreSequence(caps, {
+                alternateScreen: true,
+                mouse: true,
+            });
             expect(seq).toContain(esc.reset);
             expect(seq).toContain(esc.mouseTrackingOff);
             expect(seq).toContain(esc.bracketedPasteOff);
@@ -712,15 +797,51 @@ describe("esc environment-aware sequences", () => {
         });
         it("mirrors initSequence — skips what init skipped", () => {
             const caps = makeCaps({ bracketedPaste: false, alternateScreen: false });
-            const seq = esc.restoreSequence(caps, { alternateScreen: true, mouse: false });
+            const seq = esc.restoreSequence(caps, {
+                alternateScreen: true,
+                mouse: false,
+            });
             expect(seq).not.toContain(esc.bracketedPasteOff);
             expect(seq).not.toContain(esc.alternateScreenOff);
             expect(seq).not.toContain(esc.mouseTrackingOff);
         });
         it("returns empty string for non-TTY", () => {
             const caps = makeCaps({ isTTY: false });
-            const seq = esc.restoreSequence(caps, { alternateScreen: true, mouse: true });
+            const seq = esc.restoreSequence(caps, {
+                alternateScreen: true,
+                mouse: true,
+            });
             expect(seq).toBe("");
         });
     });
 });
+// ═══════════════════════════════════════════════════════════════════
+// win32-console.ts
+// ═══════════════════════════════════════════════════════════════════
+describe("win32-console", () => {
+    const originalPlatform = process.platform;
+    afterEach(() => {
+        Object.defineProperty(process, "platform", { value: originalPlatform });
+    });
+    describe("enableWin32Mouse", () => {
+        it("returns false on non-win32 platforms", () => {
+            Object.defineProperty(process, "platform", { value: "linux" });
+            expect(enableWin32Mouse()).toBe(false);
+        });
+        it("returns false on darwin", () => {
+            Object.defineProperty(process, "platform", { value: "darwin" });
+            expect(enableWin32Mouse()).toBe(false);
+        });
+    });
+    describe("restoreWin32Console", () => {
+        it("returns false on non-win32 platforms", () => {
+            Object.defineProperty(process, "platform", { value: "linux" });
+            expect(restoreWin32Console()).toBe(false);
+        });
+        it("returns false when no original mode was saved", () => {
+            // Even on win32, if enableWin32Mouse was never called, restore is a no-op
+            Object.defineProperty(process, "platform", { value: "win32" });
+            expect(restoreWin32Console()).toBe(false);
+        });
+    });
+});

package/dist/ansi/win32-console.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Win32 Console Mode — enables mouse input on Windows terminals.
+ *
+ * Node.js `setRawMode(true)` enables ENABLE_VIRTUAL_TERMINAL_INPUT but
+ * does NOT disable ENABLE_QUICK_EDIT_MODE (which intercepts mouse clicks
+ * for text selection) or enable ENABLE_MOUSE_INPUT. This module uses
+ * koffi to call the Win32 API directly and set the correct flags.
+ *
+ * Only loaded on win32 — no-ops on other platforms.
+ */
+/**
+ * Configure the Windows console for mouse input.
+ *
+ * Disables Quick Edit Mode (which swallows mouse clicks) and enables
+ * ENABLE_MOUSE_INPUT + ENABLE_EXTENDED_FLAGS + ENABLE_WINDOW_INPUT.
+ * Saves the original mode so it can be restored later.
+ *
+ * No-op on non-Windows platforms or if koffi is not available.
+ * Returns true if the mode was successfully changed.
+ */
+export declare function enableWin32Mouse(): boolean;
+/**
+ * Restore the original Windows console mode saved by enableWin32Mouse().
+ *
+ * No-op if enableWin32Mouse() was never called or failed.
+ * Returns true if the mode was successfully restored.
+ */
+export declare function restoreWin32Console(): boolean;

package/dist/ansi/win32-console.js

@@ -0,0 +1,122 @@
+/**
+ * Win32 Console Mode — enables mouse input on Windows terminals.
+ *
+ * Node.js `setRawMode(true)` enables ENABLE_VIRTUAL_TERMINAL_INPUT but
+ * does NOT disable ENABLE_QUICK_EDIT_MODE (which intercepts mouse clicks
+ * for text selection) or enable ENABLE_MOUSE_INPUT. This module uses
+ * koffi to call the Win32 API directly and set the correct flags.
+ *
+ * Only loaded on win32 — no-ops on other platforms.
+ */
+import { createRequire } from "node:module";
+// ── Console mode flag constants ─────────────────────────────────────
+const ENABLE_PROCESSED_INPUT = 0x0001;
+const ENABLE_LINE_INPUT = 0x0002;
+const ENABLE_ECHO_INPUT = 0x0004;
+const ENABLE_WINDOW_INPUT = 0x0008;
+const ENABLE_MOUSE_INPUT = 0x0010;
+const ENABLE_QUICK_EDIT_MODE = 0x0040;
+const ENABLE_EXTENDED_FLAGS = 0x0080;
+const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
+const STD_INPUT_HANDLE = -10;
+// ── State ───────────────────────────────────────────────────────────
+let originalMode = null;
+let _kernel32;
+function getKernel32() {
+    if (_kernel32 !== undefined)
+        return _kernel32;
+    try {
+        // koffi is an optional native dependency — dynamic require so the
+        // module loads cleanly even when koffi is absent.
+        const require = createRequire(import.meta.url);
+        const koffi = require("koffi");
+        const lib = koffi.load("kernel32.dll");
+        _kernel32 = {
+            GetStdHandle: lib.func("void* __stdcall GetStdHandle(int nStdHandle)"),
+            GetConsoleMode: lib.func("bool __stdcall GetConsoleMode(void* hConsoleHandle, _Out_ uint32_t* lpMode)"),
+            SetConsoleMode: lib.func("bool __stdcall SetConsoleMode(void* hConsoleHandle, uint32_t dwMode)"),
+        };
+    }
+    catch {
+        _kernel32 = null;
+    }
+    return _kernel32;
+}
+// ── Public API ──────────────────────────────────────────────────────
+/**
+ * Configure the Windows console for mouse input.
+ *
+ * Disables Quick Edit Mode (which swallows mouse clicks) and enables
+ * ENABLE_MOUSE_INPUT + ENABLE_EXTENDED_FLAGS + ENABLE_WINDOW_INPUT.
+ * Saves the original mode so it can be restored later.
+ *
+ * No-op on non-Windows platforms or if koffi is not available.
+ * Returns true if the mode was successfully changed.
+ */
+export function enableWin32Mouse() {
+    if (process.platform !== "win32")
+        return false;
+    const k32 = getKernel32();
+    if (!k32)
+        return false;
+    try {
+        const handle = k32.GetStdHandle(STD_INPUT_HANDLE);
+        if (!handle)
+            return false;
+        // Read current mode
+        const modeBuffer = Buffer.alloc(4);
+        if (!k32.GetConsoleMode(handle, modeBuffer))
+            return false;
+        originalMode = modeBuffer.readUInt32LE(0);
+        // Build new mode:
+        // - Keep ENABLE_VIRTUAL_TERMINAL_INPUT (set by Node raw mode)
+        // - Add ENABLE_MOUSE_INPUT + ENABLE_WINDOW_INPUT + ENABLE_EXTENDED_FLAGS
+        // - Remove ENABLE_QUICK_EDIT_MODE
+        // - Remove line/echo/processed (already cleared by raw mode)
+        let newMode = originalMode;
+        newMode |= ENABLE_MOUSE_INPUT;
+        newMode |= ENABLE_WINDOW_INPUT;
+        newMode |= ENABLE_EXTENDED_FLAGS;
+        newMode &= ~ENABLE_QUICK_EDIT_MODE;
+        newMode &= ~ENABLE_LINE_INPUT;
+        newMode &= ~ENABLE_ECHO_INPUT;
+        newMode &= ~ENABLE_PROCESSED_INPUT;
+        // Preserve VT input if it was set
+        if (originalMode & ENABLE_VIRTUAL_TERMINAL_INPUT) {
+            newMode |= ENABLE_VIRTUAL_TERMINAL_INPUT;
+        }
+        return k32.SetConsoleMode(handle, newMode);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Restore the original Windows console mode saved by enableWin32Mouse().
+ *
+ * No-op if enableWin32Mouse() was never called or failed.
+ * Returns true if the mode was successfully restored.
+ */
+export function restoreWin32Console() {
+    if (process.platform !== "win32" || originalMode === null)
+        return false;
+    const k32 = getKernel32();
+    if (!k32) {
+        originalMode = null;
+        return false;
+    }
+    try {
+        const handle = k32.GetStdHandle(STD_INPUT_HANDLE);
+        if (!handle) {
+            originalMode = null;
+            return false;
+        }
+        const result = k32.SetConsoleMode(handle, originalMode);
+        originalMode = null;
+        return result;
+    }
+    catch {
+        originalMode = null;
+        return false;
+    }
+}

package/dist/app.js

@@ -7,7 +7,8 @@
  */
 import * as esc from "./ansi/esc.js";
 import { AnsiOutput } from "./ansi/output.js";
-import { detectTerminal, } from "./ansi/terminal-env.js";
+import { detectTerminal } from "./ansi/terminal-env.js";
+import { enableWin32Mouse, restoreWin32Console } from "./ansi/win32-console.js";
 import { DrawingContext } from "./drawing/context.js";
 import { createInputProcessor } from "./input/processor.js";
 import { disableRawMode, enableRawMode } from "./input/raw-mode.js";
@@ -97,25 +98,30 @@ export class App {
         const stdout = process.stdout;
         // 1. Enable raw mode
         enableRawMode();
-        // 2. Create ANSI output
+        // 2. On Windows, configure console mode for mouse input
+        //    (must happen after raw mode so we modify the right base flags)
+        if (this._mouse) {
+            enableWin32Mouse();
+        }
+        // 3. Create ANSI output
         this._output = new AnsiOutput(stdout);
-        // 3. Prepare terminal (custom sequence instead of prepareTerminal()
+        // 4. Prepare terminal (custom sequence instead of prepareTerminal()
         //    so we can conditionally enable mouse tracking)
         this._prepareTerminal();
-        // 4. Set terminal title
+        // 5. Set terminal title
         if (this._title) {
             stdout.write(esc.setTitle(this._title));
         }
-        // 5. Create pixel buffer at terminal dimensions
+        // 6. Create pixel buffer at terminal dimensions
         const cols = stdout.columns || 80;
         const rows = stdout.rows || 24;
         this._createRenderPipeline(cols, rows);
-        // 6. Wire up input
+        // 7. Wire up input
         this._setupInput();
-        // 7. Wire up resize
+        // 8. Wire up resize
         this._resizeListener = () => this._handleResize();
         stdout.on("resize", this._resizeListener);
-        // 8. SIGINT fallback
+        // 9. SIGINT fallback
         this._sigintListener = () => this.stop();
         process.on("SIGINT", this._sigintListener);
     }
@@ -294,6 +300,8 @@ export class App {
         }
         // Restore terminal
         this._restoreTerminal();
+        // Restore Win32 console mode (before disabling raw mode)
+        restoreWin32Console();
         // Disable raw mode
         disableRawMode();
         // Resolve the run() promise

package/dist/index.d.ts

@@ -16,7 +16,8 @@ export type { Constraint, Point, Rect, Size, } from "./layout/types.js";
 export * as esc from "./ansi/esc.js";
 export { AnsiOutput } from "./ansi/output.js";
 export { stripAnsi, truncateAnsi, visibleLength, } from "./ansi/strip.js";
-export { type TerminalCaps, detectTerminal, } from "./ansi/terminal-env.js";
+export { detectTerminal, type TerminalCaps, } from "./ansi/terminal-env.js";
+export { enableWin32Mouse, restoreWin32Console, } from "./ansi/win32-console.js";
 export { DirtyRegions, DirtySnapshot } from "./render/regions.js";
 export { RenderTarget } from "./render/render-target.js";
 export { EscapeMatcher } from "./input/escape-matcher.js";

package/dist/index.js

@@ -24,6 +24,7 @@ export * as esc from "./ansi/esc.js";
 export { AnsiOutput } from "./ansi/output.js";
 export { stripAnsi, truncateAnsi, visibleLength, } from "./ansi/strip.js";
 export { detectTerminal, } from "./ansi/terminal-env.js";
+export { enableWin32Mouse, restoreWin32Console, } from "./ansi/win32-console.js";
 // ── Render pipeline ─────────────────────────────────────────────────
 export { DirtyRegions, DirtySnapshot } from "./render/regions.js";
 export { RenderTarget } from "./render/render-target.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teammates/consolonia",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Terminal UI rendering engine inspired by Consolonia. Pixel-level compositing with ANSI output.",
   "type": "module",
   "main": "dist/index.js",
@@ -41,5 +41,8 @@
   },
   "dependencies": {
     "marked": "^17.0.4"
+  },
+  "optionalDependencies": {
+    "koffi": "^2.9.0"
   }
 }