@code-yeongyu/senpi 2026.6.10 → 2026.6.12-2

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 = new Map();
         this.disableSubmit = false;
         this.tui = tui;
         this.theme = theme;
@@ -335,7 +391,24 @@ export class Editor {
         }
     }
     invalidate() {
-        // No cached state to invalidate currently
+        this.wrappedLineCache.clear();
+    }
+    getWrappedLineChunks(line, contentWidth) {
+        if (line.includes("[paste #")) {
+            return wordWrapLine(line, contentWidth, [...this.segment(line, "grapheme")]);
+        }
+        const key = `${contentWidth}\x00${line}`;
+        const cached = this.wrappedLineCache.get(key);
+        if (cached)
+            return cached;
+        const chunks = wordWrapLine(line, contentWidth);
+        if (this.wrappedLineCache.size >= 256) {
+            const oldest = this.wrappedLineCache.keys().next().value;
+            if (oldest !== undefined)
+                this.wrappedLineCache.delete(oldest);
+        }
+        this.wrappedLineCache.set(key, chunks);
+        return chunks;
     }
     render(width) {
         const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
@@ -736,7 +809,7 @@ export class Editor {
             }
             else {
                 // Line needs wrapping - use word-aware wrapping
-                const chunks = wordWrapLine(line, contentWidth, [...this.segment(line, "grapheme")]);
+                const chunks = this.getWrappedLineChunks(line, contentWidth);
                 for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
                     const chunk = chunks[chunkIndex];
                     if (!chunk)
@@ -1408,7 +1481,7 @@ export class Editor {
             }
             else {
                 // Line needs wrapping - use word-aware wrapping
-                const chunks = wordWrapLine(line, width, [...this.segment(line, "grapheme")]);
+                const chunks = this.getWrappedLineChunks(line, width);
                 for (const chunk of chunks) {
                     visualLines.push({
                         logicalLine: i,