@entelligentsia/forgecli 1.0.3 → 1.0.10

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

@@ -3,9 +3,11 @@ 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 { getSegmenter, isPunctuationChar, isWhitespaceChar, truncateToWidth, visibleWidth } from "../utils.js";
+import { getGraphemeSegmenter, getWordSegmenter, isWhitespaceChar, truncateToWidth, visibleWidth } from "../utils.js";
+import { findWordBackward, findWordForward } from "../word-navigation.js";
 import { SelectList } from "./select-list.js";
-const baseSegmenter = getSegmenter();
+const graphemeSegmenter = getGraphemeSegmenter();
+const wordSegmenter = getWordSegmenter();
 /** Regex matching paste markers like `[paste #1 +123 lines]` or `[paste #2 1234 chars]`. */
 const PASTE_MARKER_REGEX = /\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]/g;
 /** Non-global version for single-segment testing. */
@@ -21,7 +23,7 @@ function isPasteMarker(segment) {
  *
  * Only markers whose numeric ID exists in `validIds` are merged.
  */
-function segmentWithMarkers(text, validIds) {
+function segmentWithMarkers(text, baseSegmenter, validIds) {
     // Fast path: no paste markers in the text or no valid IDs.
     if (validIds.size === 0 || !text.includes("[paste #")) {
         return baseSegmenter.segment(text);
@@ -86,7 +88,7 @@ export function wordWrapLine(line, maxWidth, preSegmented) {
         return [{ text: line, startIndex: 0, endIndex: line.length }];
     }
     const chunks = [];
-    const segments = preSegmented ?? [...baseSegmenter.segment(line)];
+    const segments = preSegmented ?? [...graphemeSegmenter.segment(line)];
     let currentWidth = 0;
     let chunkStart = 0;
     // Wrap opportunity: the position after the last whitespace before a non-whitespace
@@ -225,8 +227,8 @@ export class Editor {
         return new Set(this.pastes.keys());
     }
     /** Segment text with paste-marker awareness, only merging markers with valid IDs. */
-    segment(text) {
-        return segmentWithMarkers(text, this.validPasteIds());
+    segment(text, mode) {
+        return segmentWithMarkers(text, mode === "word" ? wordSegmenter : graphemeSegmenter, this.validPasteIds());
     }
     getPaddingX() {
         return this.paddingX;
@@ -381,7 +383,7 @@ export class Editor {
                 if (after.length > 0) {
                     // Cursor is on a character (grapheme) - replace it with highlighted version
                     // Get the first grapheme from 'after'
-                    const afterGraphemes = [...this.segment(after)];
+                    const afterGraphemes = [...this.segment(after, "grapheme")];
                     const firstGrapheme = afterGraphemes[0]?.segment || "";
                     const restAfter = after.slice(firstGrapheme.length);
                     const cursor = `\x1b[7m${firstGrapheme}\x1b[0m`;
@@ -717,7 +719,7 @@ export class Editor {
             }
             else {
                 // Line needs wrapping - use word-aware wrapping
-                const chunks = wordWrapLine(line, contentWidth, [...this.segment(line)]);
+                const chunks = wordWrapLine(line, contentWidth, [...this.segment(line, "grapheme")]);
                 for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
                     const chunk = chunks[chunkIndex];
                     if (!chunk)
@@ -1030,7 +1032,7 @@ export class Editor {
             const line = this.state.lines[this.state.cursorLine] || "";
             const beforeCursor = line.slice(0, this.state.cursorCol);
             // Find the last grapheme in the text before cursor
-            const graphemes = [...this.segment(beforeCursor)];
+            const graphemes = [...this.segment(beforeCursor, "grapheme")];
             const lastGrapheme = graphemes[graphemes.length - 1];
             const graphemeLength = lastGrapheme ? lastGrapheme.segment.length : 1;
             const before = line.slice(0, this.state.cursorCol - graphemeLength);
@@ -1114,7 +1116,7 @@ export class Editor {
         // Snap cursor to atomic segment boundary (e.g. paste markers)
         // so the cursor never lands in the middle of a multi-grapheme unit.
         // Single-grapheme segments don't need snapping.
-        const segments = [...this.segment(logicalLine)];
+        const segments = [...this.segment(logicalLine, "grapheme")];
         for (const seg of segments) {
             if (seg.index > this.state.cursorCol)
                 break;
@@ -1334,7 +1336,7 @@ export class Editor {
             // Delete grapheme at cursor position (handles emojis, combining characters, etc.)
             const afterCursor = currentLine.slice(this.state.cursorCol);
             // Find the first grapheme at cursor
-            const graphemes = [...this.segment(afterCursor)];
+            const graphemes = [...this.segment(afterCursor, "grapheme")];
             const firstGrapheme = graphemes[0];
             const graphemeLength = firstGrapheme ? firstGrapheme.segment.length : 1;
             const before = currentLine.slice(0, this.state.cursorCol);
@@ -1389,7 +1391,7 @@ export class Editor {
             }
             else {
                 // Line needs wrapping - use word-aware wrapping
-                const chunks = wordWrapLine(line, width, [...this.segment(line)]);
+                const chunks = wordWrapLine(line, width, [...this.segment(line, "grapheme")]);
                 for (const chunk of chunks) {
                     visualLines.push({
                         logicalLine: i,
@@ -1441,7 +1443,7 @@ export class Editor {
                 // Moving right - move by one grapheme (handles emojis, combining characters, etc.)
                 if (this.state.cursorCol < currentLine.length) {
                     const afterCursor = currentLine.slice(this.state.cursorCol);
-                    const graphemes = [...this.segment(afterCursor)];
+                    const graphemes = [...this.segment(afterCursor, "grapheme")];
                     const firstGrapheme = graphemes[0];
                     this.setCursorCol(this.state.cursorCol + (firstGrapheme ? firstGrapheme.segment.length : 1));
                 }
@@ -1462,7 +1464,7 @@ export class Editor {
                 // Moving left - move by one grapheme (handles emojis, combining characters, etc.)
                 if (this.state.cursorCol > 0) {
                     const beforeCursor = currentLine.slice(0, this.state.cursorCol);
-                    const graphemes = [...this.segment(beforeCursor)];
+                    const graphemes = [...this.segment(beforeCursor, "grapheme")];
                     const lastGrapheme = graphemes[graphemes.length - 1];
                     this.setCursorCol(this.state.cursorCol - (lastGrapheme ? lastGrapheme.segment.length : 1));
                 }
@@ -1500,40 +1502,10 @@ export class Editor {
             }
             return;
         }
-        const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
-        const graphemes = [...this.segment(textBeforeCursor)];
-        let newCol = this.state.cursorCol;
-        // Skip trailing whitespace
-        while (graphemes.length > 0 &&
-            !isPasteMarker(graphemes[graphemes.length - 1]?.segment || "") &&
-            isWhitespaceChar(graphemes[graphemes.length - 1]?.segment || "")) {
-            newCol -= graphemes.pop()?.segment.length || 0;
-        }
-        if (graphemes.length > 0) {
-            const lastGrapheme = graphemes[graphemes.length - 1]?.segment || "";
-            if (isPasteMarker(lastGrapheme)) {
-                // Paste marker is a single atomic word
-                newCol -= graphemes.pop()?.segment.length || 0;
-            }
-            else if (isPunctuationChar(lastGrapheme)) {
-                // Skip punctuation run
-                while (graphemes.length > 0 &&
-                    isPunctuationChar(graphemes[graphemes.length - 1]?.segment || "") &&
-                    !isPasteMarker(graphemes[graphemes.length - 1]?.segment || "")) {
-                    newCol -= graphemes.pop()?.segment.length || 0;
-                }
-            }
-            else {
-                // Skip word run
-                while (graphemes.length > 0 &&
-                    !isWhitespaceChar(graphemes[graphemes.length - 1]?.segment || "") &&
-                    !isPunctuationChar(graphemes[graphemes.length - 1]?.segment || "") &&
-                    !isPasteMarker(graphemes[graphemes.length - 1]?.segment || "")) {
-                    newCol -= graphemes.pop()?.segment.length || 0;
-                }
-            }
-        }
-        this.setCursorCol(newCol);
+        this.setCursorCol(findWordBackward(currentLine, this.state.cursorCol, {
+            segment: (text) => this.segment(text, "word"),
+            isAtomicSegment: isPasteMarker,
+        }));
     }
     /**
      * Yank (paste) the most recent kill ring entry at cursor position.
@@ -1690,41 +1662,10 @@ export class Editor {
             }
             return;
         }
-        const textAfterCursor = currentLine.slice(this.state.cursorCol);
-        const segments = this.segment(textAfterCursor);
-        const iterator = segments[Symbol.iterator]();
-        let next = iterator.next();
-        let newCol = this.state.cursorCol;
-        // Skip leading whitespace
-        while (!next.done && !isPasteMarker(next.value.segment) && isWhitespaceChar(next.value.segment)) {
-            newCol += next.value.segment.length;
-            next = iterator.next();
-        }
-        if (!next.done) {
-            const firstGrapheme = next.value.segment;
-            if (isPasteMarker(firstGrapheme)) {
-                // Paste marker is a single atomic word
-                newCol += firstGrapheme.length;
-            }
-            else if (isPunctuationChar(firstGrapheme)) {
-                // Skip punctuation run
-                while (!next.done && isPunctuationChar(next.value.segment) && !isPasteMarker(next.value.segment)) {
-                    newCol += next.value.segment.length;
-                    next = iterator.next();
-                }
-            }
-            else {
-                // Skip word run
-                while (!next.done &&
-                    !isWhitespaceChar(next.value.segment) &&
-                    !isPunctuationChar(next.value.segment) &&
-                    !isPasteMarker(next.value.segment)) {
-                    newCol += next.value.segment.length;
-                    next = iterator.next();
-                }
-            }
-        }
-        this.setCursorCol(newCol);
+        this.setCursorCol(findWordForward(currentLine, this.state.cursorCol, {
+            segment: (text) => this.segment(text, "word"),
+            isAtomicSegment: isPasteMarker,
+        }));
     }
     // Slash menu only allowed on the first line of the editor
     isSlashMenuAllowed() {