@xingjisoft/neutrino 0.1.0

package/dist/terminal/input.js

@@ -0,0 +1,197 @@
+import process from "node:process";
+const ESC_TIMEOUT = 30;
+export class InputReader {
+    decoder = new TextDecoder("utf-8");
+    pending = "";
+    state = "normal";
+    csiBuf = "";
+    escTimer = null;
+    handler = null;
+    dataHandler = (chunk) => this.onData(chunk);
+    start(handler) {
+        this.handler = handler;
+        const stdin = process.stdin;
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", this.dataHandler);
+    }
+    stop() {
+        const stdin = process.stdin;
+        stdin.removeListener("data", this.dataHandler);
+        if (this.escTimer)
+            clearTimeout(this.escTimer);
+        if (stdin.isTTY)
+            stdin.setRawMode(false);
+        stdin.pause();
+    }
+    onData(chunk) {
+        this.pending += this.decoder.decode(chunk, { stream: true });
+        this.process();
+    }
+    process() {
+        const s = this.pending;
+        let i = 0;
+        while (i < s.length) {
+            const c = s[i];
+            if (this.state === "normal") {
+                if (c === "\x1b") {
+                    this.state = "esc";
+                    this.scheduleEscTimeout();
+                    i++;
+                    continue;
+                }
+                const code = c.charCodeAt(0);
+                if (c === "\r" || c === "\n") {
+                    this.emitKey("return", false, false, false, c);
+                    i++;
+                    continue;
+                }
+                if (c === "\t") {
+                    this.emitKey("tab", false, false, false, c);
+                    i++;
+                    continue;
+                }
+                if (c === "\x7f" || c === "\x08") {
+                    this.emitKey("backspace", false, false, false, c);
+                    i++;
+                    continue;
+                }
+                if (code >= 1 && code <= 26) {
+                    const name = String.fromCharCode(code + 96);
+                    this.emitKey(name, true, false, false, c);
+                    i++;
+                    continue;
+                }
+                if (code === 0) {
+                    this.emitKey(" ", true, false, false, c);
+                    i++;
+                    continue;
+                }
+                this.emitKey(c, false, false, false, c);
+                i++;
+                continue;
+            }
+            if (this.state === "esc") {
+                this.cancelEscTimeout();
+                if (c === "[" || c === "O") {
+                    this.state = "csi";
+                    this.csiBuf = "";
+                    i++;
+                    continue;
+                }
+                if (c === "\x1b") {
+                    this.emitKey("escape", false, false, false, "\x1b");
+                    this.state = "esc";
+                    this.scheduleEscTimeout();
+                    i++;
+                    continue;
+                }
+                this.emitKey(c, false, true, false, "\x1b" + c);
+                this.state = "normal";
+                i++;
+                continue;
+            }
+            // csi
+            this.csiBuf += c;
+            const cc = c.charCodeAt(0);
+            if (cc >= 0x40 && cc <= 0x7e) {
+                this.finishCsi();
+                this.state = "normal";
+            }
+            i++;
+        }
+        this.pending = "";
+    }
+    scheduleEscTimeout() {
+        if (this.escTimer)
+            clearTimeout(this.escTimer);
+        this.escTimer = setTimeout(() => {
+            this.escTimer = null;
+            if (this.state === "esc") {
+                this.state = "normal";
+                this.emitKey("escape", false, false, false, "\x1b");
+            }
+        }, ESC_TIMEOUT);
+    }
+    cancelEscTimeout() {
+        if (this.escTimer) {
+            clearTimeout(this.escTimer);
+            this.escTimer = null;
+        }
+    }
+    finishCsi() {
+        const s = this.csiBuf;
+        const final = s[s.length - 1];
+        if (final === "A")
+            this.emitKey("up", false, false, false, "\x1b[A");
+        else if (final === "B")
+            this.emitKey("down", false, false, false, "\x1b[B");
+        else if (final === "C")
+            this.emitKey("right", false, false, false, "\x1b[C");
+        else if (final === "D")
+            this.emitKey("left", false, false, false, "\x1b[D");
+        else if (final === "H")
+            this.emitKey("home", false, false, false, "\x1b[H");
+        else if (final === "F")
+            this.emitKey("end", false, false, false, "\x1b[F");
+        else if (final === "Z")
+            this.emitKey("tab", false, false, true, "\x1b[Z");
+        else if (final === "M" || final === "m") {
+            if (s[0] === "<")
+                this.handleMouse(s, final);
+        }
+        else if (final === "~") {
+            const param = s.slice(0, -1);
+            if (param === "3")
+                this.emitKey("delete", false, false, false, "\x1b[3~");
+            else if (param === "5")
+                this.emitKey("pageup", false, false, false, "\x1b[5~");
+            else if (param === "6")
+                this.emitKey("pagedown", false, false, false, "\x1b[6~");
+            else if (param === "1" || param === "7")
+                this.emitKey("home", false, false, false, "\x1b[1~");
+            else if (param === "4" || param === "8")
+                this.emitKey("end", false, false, false, "\x1b[4~");
+        }
+    }
+    handleMouse(s, final) {
+        const parts = s.slice(1).split(";");
+        if (parts.length < 3)
+            return;
+        const b = parseInt(parts[0], 10);
+        const x = parseInt(parts[1], 10) - 1;
+        const y = parseInt(parts[2], 10) - 1;
+        if (Number.isNaN(b) || Number.isNaN(x) || Number.isNaN(y))
+            return;
+        if (b === 64) {
+            this.emitMouse({ type: "wheel", dir: -1, x, y });
+        }
+        else if (b === 65) {
+            this.emitMouse({ type: "wheel", dir: 1, x, y });
+        }
+        else if (final === "M" && (b === 0 || b === 1 || b === 2)) {
+            this.emitMouse({ type: "click", x, y, button: b });
+        }
+    }
+    emitKey(name, ctrl, meta, shift, char) {
+        if (!this.handler)
+            return;
+        this.handler({
+            type: "key",
+            key: {
+                name,
+                ctrl,
+                meta,
+                shift,
+                char,
+                sequence: char,
+            },
+        });
+    }
+    emitMouse(event) {
+        if (!this.handler)
+            return;
+        this.handler({ type: "mouse", event });
+    }
+}

package/dist/terminal/renderer.js

@@ -0,0 +1,96 @@
+import process from "node:process";
+function styleKey(st) {
+    let k = "";
+    if (st.fg)
+        k += "f" + st.fg.join(",") + ";";
+    if (st.bg)
+        k += "b" + st.bg.join(",") + ";";
+    if (st.bold)
+        k += "B";
+    if (st.dim)
+        k += "d";
+    if (st.inverse)
+        k += "i";
+    return k;
+}
+function sgr(st) {
+    const codes = [];
+    if (st.bold)
+        codes.push("1");
+    if (st.dim)
+        codes.push("2");
+    if (st.inverse)
+        codes.push("7");
+    if (st.fg)
+        codes.push(`38;2;${st.fg[0]};${st.fg[1]};${st.fg[2]}`);
+    if (st.bg)
+        codes.push(`48;2;${st.bg[0]};${st.bg[1]};${st.bg[2]}`);
+    if (codes.length === 0)
+        return "\x1b[0m";
+    return "\x1b[0;" + codes.join(";") + "m";
+}
+function rowSignature(row) {
+    let out = "";
+    for (let i = 0; i < row.length; i++) {
+        const c = row[i];
+        out += c.ch + "\u0000" + styleKey(c.style) + "\u0001";
+    }
+    return out;
+}
+export class Renderer {
+    prevSig = [];
+    prevW = 0;
+    prevH = 0;
+    out = process.stdout;
+    init() {
+        this.write("\x1b[?1049h"); // alternate screen
+        this.write("\x1b[?25l"); // hide cursor
+        this.write("\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?1015h"); // mouse tracking
+    }
+    dispose() {
+        this.write("\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?1015l");
+        this.write("\x1b[?25h");
+        this.write("\x1b[?1049l");
+        this.write("\x1b[0m");
+    }
+    render(buf) {
+        const w = buf.width;
+        const h = buf.height;
+        if (w !== this.prevW || h !== this.prevH) {
+            this.prevSig = new Array(h).fill("");
+            this.prevW = w;
+            this.prevH = h;
+        }
+        let out = "";
+        for (let y = 0; y < h; y++) {
+            const row = buf.cells[y];
+            const sig = rowSignature(row);
+            if (sig !== this.prevSig[y]) {
+                out += this.renderRow(y, row);
+                this.prevSig[y] = sig;
+            }
+        }
+        if (out)
+            this.write(out);
+    }
+    renderRow(y, row) {
+        let s = `\x1b[${y + 1};1H`;
+        let lastKey = "";
+        for (let x = 0; x < row.length; x++) {
+            const cell = row[x];
+            if (cell.ch === "")
+                continue;
+            const sk = styleKey(cell.style);
+            if (sk !== lastKey) {
+                s += sgr(cell.style);
+                lastKey = sk;
+            }
+            s += cell.ch;
+        }
+        s += "\x1b[0m";
+        return s;
+    }
+    write(chunk) {
+        this.out.write(chunk);
+    }
+}

package/dist/terminal/screen.js

@@ -0,0 +1,6 @@
+export class Screen {
+    app;
+    onMouse(_ev) { }
+    onActivate() { }
+    onDeactivate() { }
+}

package/dist/ui.js

@@ -0,0 +1,150 @@
+import { C } from "./colors.js";
+import { displayWidth, truncateByWidth, wcwidth } from "./width.js";
+function chunkByWidth(text, width) {
+    const chunks = [];
+    let cur = "";
+    let curW = 0;
+    for (const ch of text) {
+        const w = wcwidth(ch.codePointAt(0) ?? 0);
+        if (curW + w > width && cur.length > 0) {
+            chunks.push(cur);
+            cur = ch;
+            curW = w;
+        }
+        else {
+            cur += ch;
+            curW += w;
+        }
+    }
+    if (cur.length > 0)
+        chunks.push(cur);
+    return chunks;
+}
+export function wrapText(text, width) {
+    if (width <= 0)
+        width = 1;
+    const lines = [];
+    for (const para of text.split("\n")) {
+        if (para.length === 0) {
+            lines.push("");
+            continue;
+        }
+        let line = "";
+        let lineW = 0;
+        for (const word of para.split(" ")) {
+            const wordW = displayWidth(word);
+            if (line.length === 0) {
+                if (wordW <= width) {
+                    line = word;
+                    lineW = wordW;
+                }
+                else {
+                    const chunks = chunkByWidth(word, width);
+                    for (let i = 0; i < chunks.length - 1; i++)
+                        lines.push(chunks[i]);
+                    line = chunks[chunks.length - 1];
+                    lineW = displayWidth(line);
+                }
+                continue;
+            }
+            if (lineW + 1 + wordW <= width) {
+                line += " " + word;
+                lineW += 1 + wordW;
+            }
+            else {
+                lines.push(line);
+                if (wordW <= width) {
+                    line = word;
+                    lineW = wordW;
+                }
+                else {
+                    const chunks = chunkByWidth(word, width);
+                    for (let i = 0; i < chunks.length - 1; i++)
+                        lines.push(chunks[i]);
+                    line = chunks[chunks.length - 1];
+                    lineW = displayWidth(line);
+                }
+            }
+        }
+        lines.push(line);
+    }
+    return lines;
+}
+export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {
+    const active = opts.active ?? true;
+    const dimmed = opts.dimmed ?? false;
+    const placeholder = opts.placeholder ?? "";
+    const h = 3;
+    const innerX = x + 2;
+    const innerW = w - 4;
+    const innerY = y + 1;
+    if (active)
+        buf.fillRect(x, y, w, h, { bg: C.highlightBg });
+    const textStyle = dimmed
+        ? { fg: C.dim, bg: C.highlightBg }
+        : active
+            ? { fg: C.white, bg: C.highlightBg }
+            : { fg: C.dim };
+    if (value.length === 0) {
+        buf.writeText(innerX, innerY, truncateByWidth(placeholder, innerW), textStylePlaceholder(active));
+        return;
+    }
+    const chars = Array.from(value);
+    const widths = chars.map((ch) => wcwidth(ch.codePointAt(0) ?? 0));
+    const cursorCp = Math.min(Array.from(value.slice(0, cursorPos)).length, chars.length);
+    let cursorCol = 0;
+    for (let i = 0; i < cursorCp; i++)
+        cursorCol += widths[i];
+    let startCp = 0;
+    if (cursorCol >= innerW) {
+        let acc = 0;
+        startCp = cursorCp;
+        while (startCp > 0) {
+            const pw = widths[startCp - 1];
+            if (acc + pw <= innerW - 1) {
+                acc += pw;
+                startCp--;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    let prefixW = 0;
+    for (let i = 0; i < startCp; i++)
+        prefixW += widths[i];
+    let endCp = chars.length;
+    let acc = 0;
+    for (let i = startCp; i < chars.length; i++) {
+        if (acc + widths[i] > innerW) {
+            endCp = i;
+            break;
+        }
+        acc += widths[i];
+    }
+    const visible = chars.slice(startCp, endCp).join("");
+    buf.writeText(innerX, innerY, visible, textStyle);
+    const cursorScreenCol = cursorCol - prefixW;
+    if (active && cursorScreenCol >= 0 && cursorScreenCol < innerW) {
+        buf.set(innerX + cursorScreenCol, innerY, " ", { fg: C.black, bg: C.accent });
+    }
+}
+function textStylePlaceholder(active) {
+    return active ? { fg: C.dim, bg: C.highlightBg } : { fg: C.dim };
+}
+export function drawTabButton(buf, x, y, w, label, selected, align = "center") {
+    const h = 3;
+    const labelW = displayWidth(label);
+    const lx = align === "left" ? x + 3 : x + Math.floor((w - labelW) / 2);
+    if (selected) {
+        buf.fillRect(x, y, w, h, { bg: C.highlightBg });
+        buf.writeText(lx, y + 1, label, { fg: C.accent, bg: C.highlightBg, bold: true });
+    }
+    else {
+        buf.writeText(lx, y + 1, label, { fg: C.dim });
+    }
+}
+export function centerVertically(totalHeight, contentHeight) {
+    const top = Math.floor((totalHeight - contentHeight) / 2);
+    return Math.max(1, top);
+}