@xingjisoft/neutrino 0.1.1 → 0.1.3

package/dist/ui.js

@@ -23,52 +23,78 @@ function chunkByWidth(text, width) {
 export function wrapText(text, width) {
     if (width <= 0)
         width = 1;
-    const lines = [];
-    for (const para of text.split("\n")) {
+    const out = [];
+    const paragraphs = text.replace(/\r\n?/g, "\n").split("\n");
+    for (const para of paragraphs) {
         if (para.length === 0) {
-            lines.push("");
+            out.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;
+        // Preserve the original indentation. Continuation lines reuse it so
+        // wrapped command output / code keeps its nesting instead of being
+        // flattened to the left margin.
+        const leadMatch = para.match(/^[ \t]*/);
+        const leadRaw = leadMatch ? leadMatch[0] : "";
+        const indent = leadRaw.replace(/\t/g, "  ");
+        const indentW = displayWidth(indent);
+        const body = para.slice(leadRaw.length);
+        // Split into words and the whitespace runs between them so runs of spaces
+        // (alignment padding in command output) are kept verbatim rather than
+        // collapsed to a single space.
+        const parts = body.match(/\s+|\S+/g) ?? [];
+        let line = indent;
+        let lineW = indentW;
+        let hasContent = false;
+        // Whitespace seen since the last word. It is only emitted together with
+        // the next word, so a line break never leaves trailing blanks behind.
+        let pending = "";
+        const newLine = () => {
+            out.push(line);
+            line = " ".repeat(indentW);
+            lineW = indentW;
+            hasContent = false;
+        };
+        const placeWord = (word) => {
+            const gap = hasContent ? pending : "";
+            pending = "";
+            const gapW = displayWidth(gap);
+            const w = displayWidth(word);
+            if (lineW + gapW + w <= width) {
+                line += gap + word;
+                lineW += gapW + w;
+                hasContent = true;
+                return;
             }
-            if (lineW + 1 + wordW <= width) {
-                line += " " + word;
-                lineW += 1 + wordW;
+            // Does not fit: break the line and drop the gap that caused the break.
+            if (hasContent)
+                newLine();
+            if (lineW + w <= width) {
+                line += word;
+                lineW += w;
+                hasContent = true;
+                return;
             }
-            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);
-                }
+            // Word is wider than an entire line: hard-wrap it by columns.
+            const avail = Math.max(1, width - lineW);
+            const chunks = chunkByWidth(word, avail);
+            for (let i = 0; i < chunks.length - 1; i++) {
+                line += chunks[i];
+                newLine();
+            }
+            line += chunks[chunks.length - 1];
+            lineW += displayWidth(chunks[chunks.length - 1]);
+            hasContent = true;
+        };
+        for (const part of parts) {
+            if (/^\s+$/.test(part)) {
+                pending += part.replace(/\t/g, "  ");
+                continue;
             }
+            placeWord(part);
         }
-        lines.push(line);
+        out.push(line);
     }
-    return lines;
+    return out;
 }
 /**
  * Compute which part of the input value is visible inside the box, given the
@@ -137,10 +163,49 @@ export function drawHint(buf, y, text) {
     const t = displayWidth(text) <= max ? text : truncateByWidth(text, max - 1) + "…";
     buf.centerText(y, t, { fg: C.dim });
 }
+/**
+ * Geometry of a vertical scrollbar, shared by the drawing code and the app's
+ * hit-testing / dragging so the two can never disagree.
+ */
+export function scrollbarGeometry(top, bottom, total, viewport, offset) {
+    const trackH = Math.max(0, bottom - top + 1);
+    const thumbH = Math.max(1, Math.round((trackH * viewport) / total));
+    const maxThumbTop = Math.max(0, trackH - thumbH);
+    const maxOffset = Math.max(1, total - viewport);
+    const clamped = Math.max(0, Math.min(offset, maxOffset));
+    const thumbTop = maxThumbTop === 0 ? 0 : Math.round((maxThumbTop * clamped) / maxOffset);
+    return { trackH, thumbH, maxThumbTop, maxOffset, thumbTop };
+}
+/**
+ * Inverse of the thumb positioning above: the scroll offset that places the
+ * thumb's top at 'thumbTop'. Used while dragging the thumb; feeding the result
+ * back through scrollbarGeometry reproduces the same 'thumbTop'.
+ */
+export function offsetFromThumbTop(g, thumbTop) {
+    if (g.maxThumbTop === 0)
+        return 0;
+    const t = Math.max(0, Math.min(thumbTop, g.maxThumbTop));
+    return Math.round((g.maxOffset * t) / g.maxThumbTop);
+}
+export function drawScrollbar(buf, x, top, bottom, total, viewport, offset, opts = {}) {
+    const trackH = bottom - top + 1;
+    if (trackH <= 0 || x < 0 || x >= buf.width)
+        return;
+    if (total <= viewport || viewport <= 0)
+        return; // nothing to scroll: hide it
+    const trackColor = opts.track ?? C.scrollTrack;
+    const thumbColor = opts.thumb ?? C.scrollThumb;
+    const g = scrollbarGeometry(top, bottom, total, viewport, offset);
+    for (let i = 0; i < g.trackH; i++) {
+        const isThumb = i >= g.thumbTop && i < g.thumbTop + g.thumbH;
+        buf.set(x, top + i, isThumb ? "█" : "│", { fg: isThumb ? thumbColor : trackColor });
+    }
+}
 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 cursorOn = opts.cursorOn ?? true;
     const h = 3;
     const innerX = x + 2;
     const innerW = w - 4;
@@ -158,22 +223,42 @@ export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {
     }
     const win = computeInputWindow(value, cursorPos, innerW);
     const chars = Array.from(value);
+    // Codepoint index of the cursor (cursorPos is a UTF-16 offset).
+    const cursorCp = Math.min(Array.from(value.slice(0, cursorPos)).length, chars.length);
     const visible = chars.slice(win.startCp, win.startCp + win.visibleCount).join("");
     buf.writeText(innerX, innerY, visible, textStyle);
-    const cursorScreenCol = cursorColAt(value, cursorPos, win);
-    if (active && cursorScreenCol >= 0 && cursorScreenCol < innerW) {
-        buf.set(innerX + cursorScreenCol, innerY, " ", { fg: C.black, bg: C.accent });
+    // Blinking block cursor. While it is "on" the character underneath is drawn
+    // inside the block in the opposite colour so the text stays legible instead
+    // of being hidden by the cursor.
+    const cursorScreenCol = cursorColAt(chars, cursorCp, win);
+    if (active && cursorOn && cursorScreenCol >= 0 && cursorScreenCol < innerW) {
+        drawBlockCursor(buf, innerX + cursorScreenCol, innerY, chars, cursorCp, cursorScreenCol, innerW);
     }
 }
-function cursorColAt(value, cursorPos, win) {
-    const chars = Array.from(value);
-    const cursorCp = Math.min(Array.from(value.slice(0, cursorPos)).length, chars.length);
+function cursorColAt(chars, cursorCp, win) {
     let col = win.prefixW;
     for (let i = win.startCp; i < cursorCp; i++) {
         col += wcwidth(chars[i].codePointAt(0) ?? 0);
     }
     return col - win.prefixW;
 }
+/**
+ * Draw a single block cursor cell. The glyph under the cursor (the character
+ * immediately to its right) is rendered in the opposite colour — a dark glyph
+ * on the accent block — so it remains readable. Past the end of the text, or
+ * when the glyph would not fit, a solid block is drawn instead.
+ */
+function drawBlockCursor(buf, x, y, chars, cursorCp, col, innerW) {
+    const cursorStyle = { fg: C.black, bg: C.accent };
+    const ch = cursorCp < chars.length ? chars[cursorCp] : "";
+    const cw = ch ? wcwidth(ch.codePointAt(0) ?? 0) : 0;
+    if (ch && ch !== " " && cw >= 1 && col + cw <= innerW) {
+        buf.writeText(x, y, ch, cursorStyle);
+    }
+    else {
+        buf.set(x, y, " ", cursorStyle);
+    }
+}
 function textStylePlaceholder(active) {
     return active ? { fg: C.dim, bg: C.highlightBg } : { fg: C.dim };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",
@@ -17,6 +17,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs",
     "prepare": "npm run build"
   },
   "keywords": [