@ashx-j/lunr-tui 0.2.8 → 0.2.10

package/dist/components/editor.js

@@ -12,33 +12,58 @@ const wordSegmenter = getWordSegmenter();
 const PASTE_MARKER_REGEX = /\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]/g;
 /** Non-global version for single-segment testing. */
 const PASTE_MARKER_SINGLE = /^\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]$/;
+/** Regex matching clipboard image chips like `[image_1]`. */
+export const IMAGE_MARKER_REGEX = /\[image_(\d+)\]/g;
+/** Non-global version for single-segment testing. */
+const IMAGE_MARKER_SINGLE = /^\[image_(\d+)\]$/;
+export function formatImageMarker(id) {
+    return `[image_${id}]`;
+}
+export function collectImageMarkerIds(text) {
+    const ids = [];
+    const seen = new Set();
+    for (const match of text.matchAll(IMAGE_MARKER_REGEX)) {
+        const id = Number.parseInt(match[1], 10);
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        ids.push(id);
+    }
+    return ids;
+}
 /** Check if a segment is a paste marker (i.e. was merged by segmentWithMarkers). */
 function isPasteMarker(segment) {
     return segment.length >= 10 && PASTE_MARKER_SINGLE.test(segment);
 }
+function isImageMarker(segment) {
+    return segment.length >= 9 && IMAGE_MARKER_SINGLE.test(segment);
+}
+function isAtomicMarker(segment) {
+    return isPasteMarker(segment) || isImageMarker(segment);
+}
 /**
  * A segmenter that wraps Intl.Segmenter and merges graphemes that fall
- * within paste markers into single atomic segments.  This makes cursor
- * movement, deletion, word-wrap, etc. treat paste markers as single units.
+ * within paste/image markers into single atomic segments.  This makes cursor
+ * movement, deletion, word-wrap, etc. treat those markers as single units.
  *
- * Only markers whose numeric ID exists in `validIds` are merged.
+ * Only markers whose numeric ID exists in a family's `validIds` are merged.
  */
-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);
-    }
-    // Find all marker spans with valid IDs.
+function segmentWithMarkers(text, baseSegmenter, families) {
     const markers = [];
-    for (const m of text.matchAll(PASTE_MARKER_REGEX)) {
-        const id = Number.parseInt(m[1], 10);
-        if (!validIds.has(id))
+    for (const family of families) {
+        if (family.validIds.size === 0 || !text.includes(family.needle))
             continue;
-        markers.push({ start: m.index, end: m.index + m[0].length });
+        for (const m of text.matchAll(family.regex)) {
+            const id = Number.parseInt(m[1], 10);
+            if (!family.validIds.has(id))
+                continue;
+            markers.push({ start: m.index, end: m.index + m[0].length });
+        }
     }
     if (markers.length === 0) {
         return baseSegmenter.segment(text);
     }
+    markers.sort((a, b) => a.start - b.start || a.end - b.end);
     // Build merged segment list.
     const baseSegments = baseSegmenter.segment(text);
     const result = [];
@@ -100,7 +125,7 @@ export function wordWrapLine(line, maxWidth, preSegmented) {
         const grapheme = seg.segment;
         const gWidth = visibleWidth(grapheme);
         const charIndex = seg.index;
-        const isWs = !isPasteMarker(grapheme) && isWhitespaceChar(grapheme);
+        const isWs = !isAtomicMarker(grapheme) && isWhitespaceChar(grapheme);
         // Overflow check before advancing.
         if (currentWidth + gWidth > maxWidth) {
             if (wrapOppIndex >= 0 && currentWidth - wrapOppWidth + gWidth <= maxWidth) {
@@ -145,13 +170,13 @@ export function wordWrapLine(line, maxWidth, preSegmented) {
         // 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))) {
+        if (isWs && next && (isAtomicMarker(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);
+            const isCjk = !isAtomicMarker(grapheme) && cjkBreakRegex.test(grapheme);
+            const nextIsCjk = !isAtomicMarker(next.segment) && cjkBreakRegex.test(next.segment);
             if (isCjk || nextIsCjk) {
                 wrapOppIndex = next.index;
                 wrapOppWidth = currentWidth;
@@ -212,6 +237,10 @@ export class Editor {
     // Paste tracking for large pastes
     pastes = new Map();
     pasteCounter = 0;
+    // Clipboard image chips: `[image_n]` stays in the editor; bytes live off-screen.
+    images = new Map();
+    imageCounter = 0;
+    submittedImages = [];
     // Bracketed paste mode buffering
     pasteBuffer = "";
     isInPaste = false;
@@ -250,9 +279,19 @@ export class Editor {
     validPasteIds() {
         return new Set(this.pastes.keys());
     }
-    /** Segment text with paste-marker awareness, only merging markers with valid IDs. */
+    /** Set of currently valid image IDs, for marker-aware segmentation. */
+    validImageIds() {
+        return new Set(this.images.keys());
+    }
+    markerFamilies() {
+        return [
+            { regex: PASTE_MARKER_REGEX, validIds: this.validPasteIds(), needle: "[paste #" },
+            { regex: IMAGE_MARKER_REGEX, validIds: this.validImageIds(), needle: "[image_" },
+        ];
+    }
+    /** Segment text with paste/image-marker awareness, only merging markers with valid IDs. */
     segment(text, mode) {
-        return segmentWithMarkers(text, mode === "word" ? wordSegmenter : graphemeSegmenter, this.validPasteIds());
+        return segmentWithMarkers(text, mode === "word" ? wordSegmenter : graphemeSegmenter, this.markerFamilies());
     }
     getPaddingX() {
         return this.paddingX;
@@ -839,6 +878,9 @@ export class Editor {
         this.exitHistoryBrowsing();
         this.pastes.clear();
         this.pasteCounter = 0;
+        this.images.clear();
+        this.imageCounter = 0;
+        // Keep submittedImages: submitValue() snapshots chips, then setText("") runs.
         const normalized = this.normalizeText(text);
         // Push undo snapshot if content differs (makes programmatic changes undoable)
         if (this.getText() !== normalized) {
@@ -860,6 +902,53 @@ export class Editor {
         this.exitHistoryBrowsing();
         this.insertTextAtCursorInternal(text);
     }
+    /**
+     * Insert an atomic `[image_n]` chip and remember the off-screen file.
+     * IDs stay stable for the current draft. The next unused number is used.
+     */
+    insertImageMarker(attachment) {
+        this.cancelAutocomplete();
+        this.pushUndoSnapshot();
+        this.lastAction = null;
+        this.exitHistoryBrowsing();
+        this.imageCounter++;
+        const id = this.imageCounter;
+        this.images.set(id, { id, path: attachment.path, mimeType: attachment.mimeType });
+        this.insertTextAtCursorInternal(formatImageMarker(id));
+        return id;
+    }
+    /**
+     * Restore previously submitted image chips into the current draft.
+     * Used by /edit so `[image_n]` stays a chip instead of becoming a path.
+     */
+    restoreImageMarkers(attachments) {
+        this.images.clear();
+        this.imageCounter = 0;
+        for (const attachment of attachments) {
+            this.images.set(attachment.id, { ...attachment });
+            if (attachment.id > this.imageCounter)
+                this.imageCounter = attachment.id;
+        }
+    }
+    /** Pending image chips still in the editor, in first-appearance order. */
+    getPendingImages() {
+        const text = this.getText();
+        const pending = [];
+        for (const id of collectImageMarkerIds(text)) {
+            const attachment = this.images.get(id);
+            if (attachment)
+                pending.push(attachment);
+        }
+        return pending;
+    }
+    /** Take and clear pending image chips. Call after the text has been submitted. */
+    takePendingImages() {
+        const pending = this.submittedImages.length > 0 ? this.submittedImages : this.getPendingImages();
+        this.submittedImages = [];
+        this.images.clear();
+        this.imageCounter = 0;
+        return pending;
+    }
     /**
      * Normalize text for editor storage:
      * - Normalize line endings (\r\n and \r -> \n)
@@ -1054,9 +1143,13 @@ export class Editor {
     submitValue() {
         this.cancelAutocomplete();
         const result = this.expandPasteMarkers(this.state.lines.join("\n")).trim();
+        // Snapshot before the editor is cleared so onSubmit can still attach files.
+        this.submittedImages = this.getPendingImages();
         this.state = { lines: [""], cursorLine: 0, cursorCol: 0 };
         this.pastes.clear();
         this.pasteCounter = 0;
+        this.images.clear();
+        this.imageCounter = 0;
         this.exitHistoryBrowsing();
         this.scrollOffset = 0;
         this.undoStack.clear();
@@ -1079,6 +1172,7 @@ export class Editor {
             const lastGrapheme = graphemes[graphemes.length - 1];
             const graphemeLength = lastGrapheme ? lastGrapheme.segment.length : 1;
             const isPastedSegmented = PASTE_MARKER_SINGLE.exec(lastGrapheme.segment);
+            const isImageSegmented = IMAGE_MARKER_SINGLE.exec(lastGrapheme.segment);
             if (isPastedSegmented) {
                 // This contains the id part e.g 4 from [paste #4 +123 lines]
                 const targetId = Number(isPastedSegmented[1]);
@@ -1096,6 +1190,10 @@ export class Editor {
                     return newText;
                 }));
             }
+            else if (isImageSegmented) {
+                const targetId = Number(isImageSegmented[1]);
+                this.images.delete(targetId);
+            }
             line = this.state.lines[this.state.cursorLine] || "";
             const before = line.slice(0, this.state.cursorCol - graphemeLength);
             const after = line.slice(this.state.cursorCol);
@@ -1401,6 +1499,10 @@ export class Editor {
             const graphemes = [...this.segment(afterCursor, "grapheme")];
             const firstGrapheme = graphemes[0];
             const graphemeLength = firstGrapheme ? firstGrapheme.segment.length : 1;
+            const deletedImage = firstGrapheme ? IMAGE_MARKER_SINGLE.exec(firstGrapheme.segment) : null;
+            if (deletedImage) {
+                this.images.delete(Number(deletedImage[1]));
+            }
             const before = currentLine.slice(0, this.state.cursorCol);
             const after = currentLine.slice(this.state.cursorCol + graphemeLength);
             this.state.lines[this.state.cursorLine] = before + after;
@@ -1577,7 +1679,7 @@ export class Editor {
         }
         this.setCursorCol(findWordBackward(currentLine, this.state.cursorCol, {
             segment: (text) => this.segment(text, "word"),
-            isAtomicSegment: isPasteMarker,
+            isAtomicSegment: isAtomicMarker,
         }));
     }
     /**
@@ -1737,7 +1839,7 @@ export class Editor {
         }
         this.setCursorCol(findWordForward(currentLine, this.state.cursorCol, {
             segment: (text) => this.segment(text, "word"),
-            isAtomicSegment: isPasteMarker,
+            isAtomicSegment: isAtomicMarker,
         }));
     }
     // Slash menu only allowed on the first line of the editor