@code-yeongyu/senpi 2026.6.10 → 2026.6.13

package/node_modules/@earendil-works/pi-tui/dist/components/editor.js

@@ -3,7 +3,7 @@ import { decodePrintableKey, matchesKey } from "../keys.js";
 import { KillRing } from "../kill-ring.js";
 import { CURSOR_MARKER } from "../tui.js";
 import { UndoStack } from "../undo-stack.js";
-import { getGraphemeSegmenter, getWordSegmenter, isWhitespaceChar, truncateToWidth, visibleWidth } from "../utils.js";
+import { cjkBreakRegex, getGraphemeSegmenter, getWordSegmenter, isWhitespaceChar, truncateToWidth, visibleWidth, } from "../utils.js";
 import { findWordBackward, findWordForward } from "../word-navigation.js";
 import { SelectList } from "./select-list.js";
 const graphemeSegmenter = getGraphemeSegmenter();
@@ -68,6 +68,49 @@ function segmentWithMarkers(text, baseSegmenter, validIds) {
     }
     return result;
 }
+function isPrintableAsciiText(text) {
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        if (code < 0x20 || code > 0x7e)
+            return false;
+    }
+    return true;
+}
+function wordWrapAsciiLine(line, maxWidth) {
+    if (line.length <= maxWidth) {
+        return [{ text: line, startIndex: 0, endIndex: line.length }];
+    }
+    const chunks = [];
+    let chunkStart = 0;
+    while (chunkStart < line.length) {
+        let chunkEnd = Math.min(line.length, chunkStart + maxWidth);
+        if (chunkEnd < line.length) {
+            let breakAt = -1;
+            for (let i = chunkEnd; i > chunkStart; i--) {
+                const code = line.charCodeAt(i - 1);
+                if (code === 0x20 || code === 0x09) {
+                    breakAt = i - 1;
+                    break;
+                }
+            }
+            if (breakAt > chunkStart)
+                chunkEnd = breakAt;
+        }
+        const raw = line.slice(chunkStart, chunkEnd);
+        const text = raw.trimEnd();
+        if (text || chunks.length === 0) {
+            chunks.push({ text, startIndex: chunkStart, endIndex: chunkStart + raw.length });
+        }
+        chunkStart = chunkEnd;
+        while (chunkStart < line.length) {
+            const code = line.charCodeAt(chunkStart);
+            if (code !== 0x20 && code !== 0x09)
+                break;
+            chunkStart++;
+        }
+    }
+    return chunks.length > 0 ? chunks : [{ text: "", startIndex: 0, endIndex: 0 }];
+}
 /**
  * Split a line into word-wrapped chunks.
  * Wraps at word boundaries when possible, falling back to character-level
@@ -83,6 +126,9 @@ export function wordWrapLine(line, maxWidth, preSegmented) {
     if (!line || maxWidth <= 0) {
         return [{ text: "", startIndex: 0, endIndex: 0 }];
     }
+    if (preSegmented === undefined && !/\s/.test(line) && !line.includes("[paste #") && isPrintableAsciiText(line)) {
+        return wordWrapAsciiLine(line, maxWidth);
+    }
     const lineWidth = visibleWidth(line);
     if (lineWidth <= maxWidth) {
         return [{ text: line, startIndex: 0, endIndex: line.length }];
@@ -140,14 +186,23 @@ export function wordWrapLine(line, maxWidth, preSegmented) {
         }
         // Advance.
         currentWidth += gWidth;
-        // Record wrap opportunity: whitespace followed by non-whitespace.
-        // Multiple spaces join (no break between them); the break point is
-        // after the last space before the next word.
+        // Record wrap opportunity: whitespace followed by non-whitespace
+        // (multiple spaces join; the break point is after the last space),
+        // or at a boundary where either side is CJK (CJK allows breaking
+        // between any adjacent characters).
         const next = segments[i + 1];
         if (isWs && next && (isPasteMarker(next.segment) || !isWhitespaceChar(next.segment))) {
             wrapOppIndex = next.index;
             wrapOppWidth = currentWidth;
         }
+        else if (!isWs && next && !isWhitespaceChar(next.segment)) {
+            const isCjk = !isPasteMarker(grapheme) && cjkBreakRegex.test(grapheme);
+            const nextIsCjk = !isPasteMarker(next.segment) && cjkBreakRegex.test(next.segment);
+            if (isCjk || nextIsCjk) {
+                wrapOppIndex = next.index;
+                wrapOppWidth = currentWidth;
+            }
+        }
     }
     // Push final chunk.
     chunks.push({ text: line.slice(chunkStart), startIndex: chunkStart, endIndex: line.length });
@@ -217,6 +272,7 @@ export class Editor {
         this.snappedFromCursorCol = null;
         // Undo support
         this.undoStack = new UndoStack();
+        this.wrappedLineCache = [];
         this.disableSubmit = false;
         this.tui = tui;
         this.theme = theme;
@@ -335,7 +391,33 @@ export class Editor {
         }
     }
     invalidate() {
-        // No cached state to invalidate currently
+        this.wrappedLineCache.length = 0;
+    }
+    getWrappedLine(lineIndex, contentWidth) {
+        const line = this.state.lines[lineIndex] || "";
+        const cached = this.wrappedLineCache[lineIndex];
+        if (cached && cached.lineRef === line && cached.contentWidth === contentWidth) {
+            return cached;
+        }
+        const width = isPrintableAsciiText(line) ? line.length : visibleWidth(line);
+        if (line.includes("[paste #")) {
+            return {
+                width,
+                chunks: width <= contentWidth
+                    ? [{ text: line, startIndex: 0, endIndex: line.length }]
+                    : wordWrapLine(line, contentWidth, [...this.segment(line, "grapheme")]),
+            };
+        }
+        const wrapped = {
+            lineRef: line,
+            contentWidth,
+            width,
+            chunks: width <= contentWidth
+                ? [{ text: line, startIndex: 0, endIndex: line.length }]
+                : wordWrapLine(line, contentWidth),
+        };
+        this.wrappedLineCache[lineIndex] = wrapped;
+        return wrapped;
     }
     render(width) {
         const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
@@ -706,6 +788,7 @@ export class Editor {
         const layoutLines = [];
         if (this.state.lines.length === 0 || (this.state.lines.length === 1 && this.state.lines[0] === "")) {
             // Empty editor
+            this.wrappedLineCache.length = this.state.lines.length;
             layoutLines.push({
                 text: "",
                 hasCursor: true,
@@ -717,8 +800,8 @@ export class Editor {
         for (let i = 0; i < this.state.lines.length; i++) {
             const line = this.state.lines[i] || "";
             const isCurrentLine = i === this.state.cursorLine;
-            const lineVisibleWidth = visibleWidth(line);
-            if (lineVisibleWidth <= contentWidth) {
+            const wrappedLine = this.getWrappedLine(i, contentWidth);
+            if (wrappedLine.width <= contentWidth) {
                 // Line fits in one layout line
                 if (isCurrentLine) {
                     layoutLines.push({
@@ -736,7 +819,7 @@ export class Editor {
             }
             else {
                 // Line needs wrapping - use word-aware wrapping
-                const chunks = wordWrapLine(line, contentWidth, [...this.segment(line, "grapheme")]);
+                const chunks = wrappedLine.chunks;
                 for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
                     const chunk = chunks[chunkIndex];
                     if (!chunk)
@@ -783,6 +866,7 @@ export class Editor {
                 }
             }
         }
+        this.wrappedLineCache.length = this.state.lines.length;
         return layoutLines;
     }
     getText() {
@@ -1408,7 +1492,7 @@ export class Editor {
             }
             else {
                 // Line needs wrapping - use word-aware wrapping
-                const chunks = wordWrapLine(line, width, [...this.segment(line, "grapheme")]);
+                const chunks = this.getWrappedLine(i, width).chunks;
                 for (const chunk of chunks) {
                     visualLines.push({
                         logicalLine: i,