ink-prompt 0.2.2 → 0.2.4

package/dist/components/MultilineInput/__tests__/BlockRegistry.test.js

@@ -0,0 +1,225 @@
+import { describe, it, expect } from 'vitest';
+import { createBlockState, createPasteBlockEntry, createImageBlockEntry, removeBlock, getBlock, getDisplayLine, getValue, bufferColToDisplayCol, displayColToBufferCol, getValueCursorOffset, getCursorFromValueOffset, } from '../BlockRegistry.js';
+import { parseBlockMarkers } from '../BlockMarker.js';
+function makeImageRef(overrides = {}) {
+    return {
+        id: 'img1',
+        data: '',
+        mimeType: 'image/png',
+        byteSize: 100,
+        displayNumber: 1,
+        ...overrides,
+    };
+}
+describe('createBlockState', () => {
+    it('creates empty state with counters at 1', () => {
+        const state = createBlockState();
+        expect(state.entries.size).toBe(0);
+        expect(state.nextPasteNumber).toBe(1);
+        expect(state.nextImageNumber).toBe(1);
+    });
+});
+describe('createPasteBlockEntry', () => {
+    it('adds paste block and returns marker', () => {
+        const state = createBlockState();
+        const { id, marker, state: newState } = createPasteBlockEntry(state, 'original text', '[Paste text #1]');
+        expect(id).toBeTruthy();
+        expect(marker).toContain('p:');
+        expect(marker).toContain(':1');
+        expect(newState.entries.size).toBe(1);
+        expect(newState.nextPasteNumber).toBe(2);
+        expect(newState.nextImageNumber).toBe(1);
+        const entry = newState.entries.get(id);
+        expect(entry.kind).toBe('paste');
+        if (entry.kind === 'paste') {
+            expect(entry.originalText).toBe('original text');
+            expect(entry.displayText).toBe('[Paste text #1]');
+            expect(entry.displayNumber).toBe(1);
+        }
+    });
+    it('increments paste counter', () => {
+        const state = createBlockState();
+        const { state: s1 } = createPasteBlockEntry(state, 'a', '[#1]');
+        const { state: s2 } = createPasteBlockEntry(s1, 'b', '[#2]');
+        expect(s2.nextPasteNumber).toBe(3);
+        expect(s2.nextImageNumber).toBe(1);
+        expect(s2.entries.size).toBe(2);
+    });
+});
+describe('createImageBlockEntry', () => {
+    it('adds image block and returns marker', () => {
+        const state = createBlockState();
+        const imgRef = makeImageRef();
+        const { id, marker, state: newState } = createImageBlockEntry(state, imgRef);
+        expect(id).toBe('img1');
+        expect(marker).toContain('i:');
+        expect(marker).toContain(':1');
+        expect(newState.entries.size).toBe(1);
+        expect(newState.nextImageNumber).toBe(2);
+        expect(newState.nextPasteNumber).toBe(1);
+        const entry = newState.entries.get(id);
+        expect(entry.kind).toBe('image');
+        if (entry.kind === 'image') {
+            expect(entry.data).toBe('');
+            expect(entry.mimeType).toBe('image/png');
+            expect(entry.byteSize).toBe(100);
+            expect(entry.displayNumber).toBe(1);
+        }
+    });
+    it('increments image counter', () => {
+        const state = createBlockState();
+        const { state: s1 } = createImageBlockEntry(state, makeImageRef({ id: 'a' }));
+        const { state: s2 } = createImageBlockEntry(s1, makeImageRef({ id: 'b', displayNumber: 2 }));
+        expect(s2.nextImageNumber).toBe(3);
+        expect(s2.nextPasteNumber).toBe(1);
+        expect(s2.entries.size).toBe(2);
+    });
+    it('uses image ref displayNumber for marker and counter', () => {
+        const state = createBlockState();
+        const { marker, state: newState } = createImageBlockEntry(state, makeImageRef({ id: 'img5', displayNumber: 5 }));
+        expect(marker).toContain(':5');
+        expect(newState.nextImageNumber).toBe(6);
+        const entry = newState.entries.get('img5');
+        expect(entry.displayNumber).toBe(5);
+    });
+    it('paste and image counters are independent', () => {
+        const state = createBlockState();
+        const { state: s1 } = createPasteBlockEntry(state, 'text', '[Paste text #1]');
+        const { state: s2 } = createImageBlockEntry(s1, makeImageRef());
+        expect(s2.nextPasteNumber).toBe(2);
+        expect(s2.nextImageNumber).toBe(2);
+    });
+});
+describe('removeBlock', () => {
+    it('removes block by id', () => {
+        const state = createBlockState();
+        const { id, state: s1 } = createPasteBlockEntry(state, 'a', '[#1]');
+        expect(s1.entries.size).toBe(1);
+        const s2 = removeBlock(s1, id);
+        expect(s2.entries.size).toBe(0);
+    });
+    it('does nothing for non-existent id', () => {
+        const state = createBlockState();
+        const s1 = removeBlock(state, 'nonexistent');
+        expect(s1.entries.size).toBe(0);
+    });
+});
+describe('getBlock', () => {
+    it('returns entry by id', () => {
+        const state = createBlockState();
+        const { id, state: s1 } = createPasteBlockEntry(state, 'a', '[#1]');
+        const entry = getBlock(s1, id);
+        expect(entry).toBeDefined();
+        expect(entry.kind).toBe('paste');
+    });
+    it('returns undefined for non-existent id', () => {
+        const state = createBlockState();
+        expect(getBlock(state, 'nope')).toBeUndefined();
+    });
+});
+describe('getDisplayLine', () => {
+    it('expands paste marker to display text', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'original', '[Custom #1]');
+        const line = `Hello ${marker} world`;
+        expect(getDisplayLine(line, s1.entries)).toBe('Hello [Custom #1] world');
+    });
+    it('expands image marker to display text', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createImageBlockEntry(state, makeImageRef());
+        const line = `a${marker}b`;
+        expect(getDisplayLine(line, s1.entries)).toBe('a[Pasted Image #1]b');
+    });
+    it('returns line unchanged if no markers', () => {
+        const state = createBlockState();
+        expect(getDisplayLine('plain text', state.entries)).toBe('plain text');
+    });
+});
+describe('getValue', () => {
+    it('expands paste markers to original text', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'long original text', '[#1]');
+        const lines = [`Hello ${marker} world`];
+        expect(getValue(lines, s1.entries)).toBe('Hello long original text world');
+    });
+    it('leaves image markers as raw markers', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createImageBlockEntry(state, makeImageRef());
+        const lines = [`a${marker}b`];
+        expect(getValue(lines, s1.entries)).toBe(`a${marker}b`);
+    });
+    it('handles multiple lines', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'long', '[#1]');
+        const lines = [`line1 ${marker}`, 'line2'];
+        expect(getValue(lines, s1.entries)).toBe('line1 long\nline2');
+    });
+    it('returns original lines if no entries', () => {
+        const state = createBlockState();
+        expect(getValue(['hello'], state.entries)).toBe('hello');
+    });
+});
+describe('bufferColToDisplayCol', () => {
+    it('handles plain text without markers', () => {
+        const state = createBlockState();
+        expect(bufferColToDisplayCol('hello', 3, state.entries)).toBe(3);
+    });
+    it('maps column before marker', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'x', '[Display]');
+        const line = `ab${marker}cd`;
+        expect(bufferColToDisplayCol(line, 0, s1.entries)).toBe(0);
+        expect(bufferColToDisplayCol(line, 1, s1.entries)).toBe(1);
+        expect(bufferColToDisplayCol(line, 2, s1.entries)).toBe(2);
+    });
+    it('maps column within paste marker to display length', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'x', '[Display]');
+        const line = `ab${marker}cd`;
+        // marker is at buffer positions 2-~15
+        const markers = parseBlockMarkers(line);
+        const m = markers[0];
+        // Any column within the marker should map to display col = 2 + 9 = 11
+        expect(bufferColToDisplayCol(line, m.start + 1, s1.entries)).toBe(11);
+        expect(bufferColToDisplayCol(line, m.end - 1, s1.entries)).toBe(11);
+    });
+});
+describe('getValueCursorOffset', () => {
+    it('computes offset in expanded value', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'hello', '[#1]');
+        const lines = [`${marker} world`];
+        // marker expands to 5 chars, so cursor at buffer position 0 maps to value position 0
+        expect(getValueCursorOffset(lines, { line: 0, column: 0 }, s1.entries)).toBe(0);
+        // Cursor after marker in buffer maps to value position after original text
+        const markers = parseBlockMarkers(marker);
+        expect(getValueCursorOffset(lines, { line: 0, column: markers[0].end }, s1.entries)).toBe(5);
+        expect(getValueCursorOffset(lines, { line: 0, column: markers[0].end + 1 }, s1.entries)).toBe(6);
+    });
+});
+describe('getCursorFromValueOffset', () => {
+    it('converts value offset back to buffer cursor', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'hello', '[#1]');
+        const lines = [`${marker} world`];
+        const markers = parseBlockMarkers(marker);
+        const cursor = getCursorFromValueOffset(lines, 5, s1.entries);
+        expect(cursor.line).toBe(0);
+        expect(cursor.column).toBe(markers[0].end);
+    });
+});
+describe('displayColToBufferCol', () => {
+    it('handles plain text without markers', () => {
+        const state = createBlockState();
+        expect(displayColToBufferCol('hello', 3, state.entries)).toBe(3);
+    });
+    it('maps display column past marker to buffer column past marker', () => {
+        const state = createBlockState();
+        const { marker, state: s1 } = createPasteBlockEntry(state, 'x', '[Display]');
+        const line = `ab${marker}cd`;
+        const markers = parseBlockMarkers(line);
+        const displayLen = '[Display]'.length; // 9
+        // display position after marker: 2 + 9 = 11 → buffer after marker
+        expect(displayColToBufferCol(line, 2 + displayLen, s1.entries)).toBe(markers[0].end);
+    });
+});

package/dist/components/MultilineInput/__tests__/Placeholder.integration.test.js

@@ -1,6 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { renderHook, act } from '@testing-library/react';
 import { useTextInput } from '../useTextInput.js';
+import { parseBlockMarkers } from '../BlockMarker.js';
+import { BLOCK_OPEN } from '../BlockMarker.js';
 describe('Placeholder integration with useTextInput', () => {
     const longText = 'x'.repeat(200);
     it('creates a placeholder when pasting text exceeding pasteThreshold', () => {
@@ -11,13 +13,12 @@ describe('Placeholder integration with useTextInput', () => {
         act(() => {
             result.current.insert(longText);
         });
-        // Text should contain the placeholder marker
-        expect(result.current.buffer.lines[0]).toContain('\x00P');
-        // Value should return the original text
+        const line = result.current.buffer.lines[0];
+        expect(line).toContain(BLOCK_OPEN);
+        expect(line).toContain('p:');
         expect(result.current.value).toBe(longText);
-        // Cursor should be after the placeholder
         const bufLine = result.current.buffer.lines[0];
-        const markerEnd = bufLine.length; // marker is the only thing on the line
+        const markerEnd = bufLine.length;
         expect(result.current.cursor).toEqual({ line: 0, column: markerEnd });
     });
     it('does not create placeholder when pasteThreshold is not set', () => {
@@ -27,7 +28,6 @@ describe('Placeholder integration with useTextInput', () => {
         act(() => {
             result.current.insert(longText);
         });
-        // Should contain the actual text, not a marker
         expect(result.current.value).toBe(longText);
         expect(result.current.buffer.lines[0]).toBe(longText);
     });
@@ -49,14 +49,12 @@ describe('Placeholder integration with useTextInput', () => {
             undoDebounceMs: 0,
         }));
         act(() => { result.current.insert(longText); });
-        // Move cursor to end to insert more
         act(() => { result.current.insert(' '); });
         act(() => { result.current.insert(longText + longText); });
-        // Two placeholders should exist
         const line = result.current.buffer.lines[0];
-        expect(line.match(/\x00P\d+\x00/g)?.length).toBeGreaterThanOrEqual(2);
-        // Different IDs
-        const ids = line.match(/\x00P(\d+)\x00/g).map(s => parseInt(s.match(/\d+/)[0], 10));
+        const markers = parseBlockMarkers(line);
+        expect(markers.length).toBeGreaterThanOrEqual(2);
+        const ids = markers.map(m => m.id);
         expect(new Set(ids).size).toBe(ids.length);
     });
     it('value returns original text with multiple placeholders', () => {
@@ -78,8 +76,6 @@ describe('Placeholder integration with useTextInput', () => {
         }));
         act(() => { result.current.insert(longText); });
         expect(result.current.value).toBe(longText);
-        expect(result.current.buffer.lines[0]).toContain('\x00P0\x00');
-        // Backspace should remove the whole placeholder
         act(() => { result.current.delete(); });
         expect(result.current.value).toBe('');
         expect(result.current.buffer.lines[0]).toBe('');
@@ -90,17 +86,13 @@ describe('Placeholder integration with useTextInput', () => {
             pasteThreshold: 10,
             undoDebounceMs: 0,
         }));
-        // Insert text, then go back to start
         act(() => { result.current.insert('A'); });
         act(() => { result.current.insert(longText); });
-        // Move cursor to start
         act(() => { result.current.moveCursor('lineStart'); });
         expect(result.current.cursor).toEqual({ line: 0, column: 0 });
-        // Forward delete should delete 'A' first
         act(() => { result.current.deleteForward(); });
         expect(result.current.value).toBe(longText);
         expect(result.current.cursor).toEqual({ line: 0, column: 0 });
-        // Forward delete again should delete the placeholder
         act(() => { result.current.deleteForward(); });
         expect(result.current.value).toBe('');
         expect(result.current.buffer.lines[0]).toBe('');
@@ -113,14 +105,17 @@ describe('Placeholder integration with useTextInput', () => {
         act(() => { result.current.insert('A'); });
         act(() => { result.current.insert(longText); });
         act(() => { result.current.insert('B'); });
-        // Cursor at end: 'A'(0) + marker(1-4) + 'B'(5) → column 6
-        expect(result.current.cursor.column).toBe(6);
-        // Move left to column 5 (valid: before 'B', after marker)
+        const line = result.current.buffer.lines[0];
+        const markers = parseBlockMarkers(line);
+        const marker = markers[0];
+        const endCol = marker.end + 1; // 1 for B
+        expect(result.current.cursor.column).toBe(endCol);
+        // Move left to position after marker (before B)
         act(() => { result.current.moveCursor('left'); });
-        expect(result.current.cursor.column).toBe(5);
-        // Move left again - lands inside marker, skip to marker start (column 1)
+        expect(result.current.cursor.column).toBe(marker.end);
+        // Move left again - should jump to marker start
         act(() => { result.current.moveCursor('left'); });
-        expect(result.current.cursor.column).toBe(1);
+        expect(result.current.cursor.column).toBe(marker.start);
     });
     it('right arrow jumps over placeholder', () => {
         const { result } = renderHook(() => useTextInput({
@@ -130,15 +125,17 @@ describe('Placeholder integration with useTextInput', () => {
         act(() => { result.current.insert('A'); });
         act(() => { result.current.insert(longText); });
         act(() => { result.current.insert('B'); });
-        // Move cursor to start
         act(() => { result.current.moveCursor('lineStart'); });
         expect(result.current.cursor.column).toBe(0);
-        // Move right to column 1 (valid: after 'A', before marker)
+        const line = result.current.buffer.lines[0];
+        const markers = parseBlockMarkers(line);
+        const marker = markers[0];
+        // Move right past 'A'
         act(() => { result.current.moveCursor('right'); });
-        expect(result.current.cursor.column).toBe(1);
-        // Move right again - lands inside marker, skip to marker end (column 5)
+        expect(result.current.cursor.column).toBe(marker.start);
+        // Move right again - should jump to marker end
         act(() => { result.current.moveCursor('right'); });
-        expect(result.current.cursor.column).toBe(5);
+        expect(result.current.cursor.column).toBe(marker.end);
     });
     it('undo restores state before placeholder creation', () => {
         const { result } = renderHook(() => useTextInput({
@@ -148,11 +145,9 @@ describe('Placeholder integration with useTextInput', () => {
         act(() => { result.current.insert('A'); });
         act(() => { result.current.insert(longText); });
         expect(result.current.value).toBe('A' + longText);
-        // Undo should remove the paste
         act(() => { result.current.undo(); });
         expect(result.current.value).toBe('A');
         expect(result.current.cursor).toEqual({ line: 0, column: 1 });
-        // Undo again should remove 'A'
         act(() => { result.current.undo(); });
         expect(result.current.value).toBe('');
     });
@@ -164,13 +159,11 @@ describe('Placeholder integration with useTextInput', () => {
         act(() => { result.current.insert('A'); });
         act(() => { result.current.insert(longText); });
         expect(result.current.value).toBe('A' + longText);
-        // Undo the placeholder creation
         act(() => { result.current.undo(); });
         expect(result.current.value).toBe('A');
-        // Redo should bring back the placeholder
         act(() => { result.current.redo(); });
         expect(result.current.value).toBe('A' + longText);
-        expect(result.current.buffer.lines[0]).toContain('\x00P');
+        expect(result.current.buffer.lines[0]).toContain(BLOCK_OPEN);
     });
     it('handles multi-line original text', () => {
         const { result } = renderHook(() => useTextInput({
@@ -179,10 +172,8 @@ describe('Placeholder integration with useTextInput', () => {
         }));
         const multiLineText = 'hello\nworld\nfoo';
         act(() => { result.current.insert(multiLineText); });
-        // Value should contain the original multi-line text
         expect(result.current.value).toBe(multiLineText);
-        // Buffer should have the marker on a single line
-        expect(result.current.buffer.lines[0]).toContain('\x00P0\x00');
+        expect(result.current.buffer.lines[0]).toContain(BLOCK_OPEN);
         expect(result.current.buffer.lines.length).toBe(1);
     });
     it('typing after placeholder works correctly', () => {
@@ -194,7 +185,7 @@ describe('Placeholder integration with useTextInput', () => {
         act(() => { result.current.insert(' and more'); });
         expect(result.current.value).toBe(longText + ' and more');
         const line = result.current.buffer.lines[0];
-        expect(line).toContain('\x00P0\x00');
+        expect(line).toContain(BLOCK_OPEN);
         expect(line).toContain(' and more');
     });
     it('typing before placeholder works correctly', () => {
@@ -203,12 +194,11 @@ describe('Placeholder integration with useTextInput', () => {
             undoDebounceMs: 0,
         }));
         act(() => { result.current.insert(longText); });
-        // Move cursor to start
         act(() => { result.current.moveCursor('lineStart'); });
         act(() => { result.current.insert('prefix '); });
         expect(result.current.value).toBe('prefix ' + longText);
         const line = result.current.buffer.lines[0];
-        expect(line).toContain('\x00P0\x00');
+        expect(line).toContain(BLOCK_OPEN);
         expect(line).toContain('prefix ');
     });
     it('setText clears placeholders', () => {
@@ -217,24 +207,25 @@ describe('Placeholder integration with useTextInput', () => {
             undoDebounceMs: 0,
         }));
         act(() => { result.current.insert(longText); });
-        expect(result.current.placeholderState.placeholders.size).toBe(1);
+        expect(result.current.blockState.entries.size).toBe(1);
         act(() => { result.current.setText('new text'); });
         expect(result.current.value).toBe('new text');
-        expect(result.current.placeholderState.placeholders.size).toBe(0);
+        expect(result.current.blockState.entries.size).toBe(0);
     });
     it('custom formatPastePlaceholder is used for display text', () => {
-        const formatter = (id) => `📋Pasted#${id}📋`;
+        const formatter = (displayNumber) => `📋Pasted#${displayNumber}📋`;
         const { result } = renderHook(() => useTextInput({
             pasteThreshold: 10,
             formatPastePlaceholder: formatter,
             undoDebounceMs: 0,
         }));
         act(() => { result.current.insert(longText); });
-        // Value should still have original text
         expect(result.current.value).toBe(longText);
-        // The placeholder should have the custom display text
-        const placeholderInfo = result.current.placeholderState.placeholders.get(0);
-        expect(placeholderInfo?.displayText).toBe('📋Pasted#0📋');
+        const entry = result.current.blockState.entries.values().next().value;
+        expect(entry.kind).toBe('paste');
+        if (entry.kind === 'paste') {
+            expect(entry.displayText).toBe('📋Pasted#1📋');
+        }
     });
     it('placeholder counter is per useTextInput instance', () => {
         const { result: r1 } = renderHook(() => useTextInput({
@@ -249,19 +240,17 @@ describe('Placeholder integration with useTextInput', () => {
             r1.current.insert(longText);
             r2.current.insert(longText);
         });
-        expect(r1.current.placeholderState.placeholders.get(0)).toBeDefined();
-        expect(r2.current.placeholderState.placeholders.get(0)).toBeDefined();
+        expect(r1.current.blockState.entries.size).toBe(1);
+        expect(r2.current.blockState.entries.size).toBe(1);
     });
     it('strips \x00 from user input so it cannot impersonate a placeholder marker', () => {
         const { result } = renderHook(() => useTextInput({
             undoDebounceMs: 0,
         }));
-        // Forge what looks like a marker for id 0
         act(() => { result.current.insert('hello\x00P0\x00world'); });
-        // \x00 bytes are stripped, leaving plain text — no fake marker in buffer or value
         expect(result.current.buffer.lines[0]).toBe('helloP0world');
         expect(result.current.value).toBe('helloP0world');
-        expect(result.current.placeholderState.placeholders.size).toBe(0);
+        expect(result.current.blockState.entries.size).toBe(0);
     });
     it('backspace at line start merges with previous line containing placeholder', () => {
         const { result } = renderHook(() => useTextInput({
@@ -270,19 +259,14 @@ describe('Placeholder integration with useTextInput', () => {
         }));
         act(() => { result.current.insert(longText); });
         act(() => { result.current.insert('\n'); });
-        act(() => { result.current.insert('abc'); }); // 3 chars, below threshold
-        // Cursor should be at end of line 1
-        expect(result.current.cursor).toEqual({ line: 1, column: 3 }); // 'abc' = 3 chars
-        // Move to start of second line
+        act(() => { result.current.insert('abc'); });
+        expect(result.current.cursor).toEqual({ line: 1, column: 3 });
         for (let i = 0; i < 3; i++) {
             act(() => { result.current.moveCursor('left'); });
         }
         expect(result.current.cursor).toEqual({ line: 1, column: 0 });
-        // Backspace should merge lines
         act(() => { result.current.delete(); });
         expect(result.current.cursor.line).toBe(0);
-        // After merge: "\x00P0\x00abc" = 7 chars, cursor at previousLine.length = 4
-        expect(result.current.cursor.column).toBe(4);
         expect(result.current.value).toBe(longText + 'abc');
     });
     it('delete at end of line merges with next line containing placeholder', () => {
@@ -290,13 +274,11 @@ describe('Placeholder integration with useTextInput', () => {
             pasteThreshold: 10,
             undoDebounceMs: 0,
         }));
-        act(() => { result.current.insert('hi'); }); // 2 chars, below threshold
+        act(() => { result.current.insert('hi'); });
         act(() => { result.current.insert('\n'); });
         act(() => { result.current.insert(longText); });
-        // Move to end of first line
         act(() => { result.current.moveCursor('up'); });
-        expect(result.current.cursor).toEqual({ line: 0, column: 2 }); // end of 'hi'
-        // Forward delete should merge lines
+        expect(result.current.cursor).toEqual({ line: 0, column: 2 });
         act(() => { result.current.deleteForward(); });
         expect(result.current.value).toBe('hi' + longText);
     });
@@ -307,12 +289,9 @@ describe('Placeholder integration with useTextInput', () => {
         }));
         act(() => { result.current.insert('A'); });
         const longLen = longText.length;
-        // Before paste, cursor offset = 1
         expect(result.current.cursorOffset).toBe(1);
         act(() => { result.current.insert(longText); });
-        // After paste, cursor offset should be 1 + longLen (after the expanded text)
         expect(result.current.cursorOffset).toBe(1 + longLen);
-        // Value is A + longText (length 1 + longLen)
         expect(result.current.value.length).toBe(1 + longLen);
     });
 });

package/dist/components/MultilineInput/__tests__/TextBuffer_images.test.js

@@ -1,39 +1,29 @@
 import { describe, it, expect } from 'vitest';
 import { createBuffer, insertText, deleteChar, deleteCharForward, moveCursor, getVisualRows, getTextContent, } from '../TextBuffer.js';
-import { createSentinel, getPlaceholderText } from '../ImageSentinel.js';
+import { createBlockMarker, getBlockPlaceholderText } from '../BlockMarker.js';
 describe('TextBuffer with sentinels', () => {
-    const sentinel1 = createSentinel('img1', 1);
-    const sentinel2 = createSentinel('img2', 2);
-    const placeholder1 = getPlaceholderText(1); // "[Pasted Image #1]" (17 chars)
-    const placeholder2 = getPlaceholderText(2); // "[Pasted Image #2]" (17 chars)
+    const sentinel1 = createBlockMarker('i', 'img1', 1);
+    const sentinel2 = createBlockMarker('i', 'img2', 2);
+    const placeholder1 = getBlockPlaceholderText('i', 1); // "[Pasted Image #1]" (17 chars)
+    const placeholder2 = getBlockPlaceholderText('i', 2); // "[Pasted Image #2]" (17 chars)
     describe('getVisualRows', () => {
         it('treats sentinel as atomic block with placeholder visual width', () => {
             const line = `${sentinel1}`;
             const rows = getVisualRows(line, 20);
-            // The sentinel takes up placeholder text width (17)
             expect(rows).toEqual([
-                { start: 0, length: sentinel1.length }, // whole sentinel as one chunk
+                { start: 0, length: sentinel1.length },
             ]);
         });
         it('does not split a sentinel block across visual rows', () => {
-            // Sentinel (17 visual width) + "abc" (3) = 20 total, use width 20
             const line = `${sentinel1}abc`;
             const rows = getVisualRows(line, 20);
-            // All fits on one row
             expect(rows.length).toBe(1);
             expect(rows[0].start).toBe(0);
             expect(rows[0].length).toBe(line.length);
         });
         it('wraps text around sentinel blocks', () => {
-            // A sentinel in the middle, wrap at a narrow width
             const line = `a${sentinel1}b`;
             const rows = getVisualRows(line, 3);
-            // Each sentinel block is atomic and takes up its full visual width
-            // "a" (1) + sentinel (5 actual chars but 17 visual width) = 18 > 3, so splits
-            // The sentinel can't be split so it goes on its own row
-            // But "a" (1) fits in first row
-            // Then sentinel (17 visual) might need to be on its own row
-            // Then "b" (1) on next
             expect(rows.length).toBeGreaterThanOrEqual(1);
         });
         it('renders empty array for empty line', () => {
@@ -44,14 +34,13 @@ describe('TextBuffer with sentinels', () => {
     describe('moveCursor left with sentinels', () => {
         it('jumps over sentinel when cursor is right after it', () => {
             const buffer = createBuffer(`hello${sentinel1}world`);
-            const cursor = { line: 0, column: `hello${sentinel1}`.length }; // right after sentinel
+            const cursor = { line: 0, column: `hello${sentinel1}`.length };
             const result = moveCursor(buffer, cursor, 'left');
-            // Should jump to before the sentinel opener (after "hello")
             expect(result).toEqual({ line: 0, column: 5 });
         });
         it('normal left movement when not adjacent to sentinel', () => {
             const buffer = createBuffer(`${sentinel1}world`);
-            const cursor = { line: 0, column: `${sentinel1}world`.length }; // end of "world"
+            const cursor = { line: 0, column: `${sentinel1}world`.length };
             const result = moveCursor(buffer, cursor, 'left');
             expect(result).toEqual({ line: 0, column: `${sentinel1}worl`.length });
         });
@@ -59,9 +48,8 @@ describe('TextBuffer with sentinels', () => {
     describe('moveCursor right with sentinels', () => {
         it('jumps over sentinel when cursor is right before it', () => {
             const buffer = createBuffer(`hello${sentinel1}world`);
-            const cursor = { line: 0, column: 5 }; // right before sentinel
+            const cursor = { line: 0, column: 5 };
             const result = moveCursor(buffer, cursor, 'right');
-            // Should jump to after the sentinel closer
             expect(result).toEqual({ line: 0, column: `hello${sentinel1}`.length });
         });
         it('normal right movement when not adjacent to sentinel', () => {
@@ -74,18 +62,12 @@ describe('TextBuffer with sentinels', () => {
     describe('deleteChar (backspace) with sentinels', () => {
         it('removes whole sentinel block when deleting at closer', () => {
             const buffer = createBuffer(`hello${sentinel1}world`);
-            // Use getTextContent to find offset
-            // Cursor: right after sentinel (at end of sentinel block)
             const cursor = { line: 0, column: `hello${sentinel1}`.length };
             const result = deleteChar(buffer, cursor);
             expect(getTextContent(result.buffer)).toBe('helloworld');
             expect(result.cursor).toEqual({ line: 0, column: 5 });
         });
         it('normal backspace when not near sentinel', () => {
-            const buffer = createBuffer(`hello${sentinel1}`);
-            const cursor = { line: 0, column: `hello${sentinel1}`.length };
-            // This is right after sentinel, so the first backspace removes the sentinel
-            // Just test a normal backspace on regular text
             const normalBuffer = createBuffer('hello');
             const normalCursor = { line: 0, column: 5 };
             const result = deleteChar(normalBuffer, normalCursor);
@@ -95,7 +77,7 @@ describe('TextBuffer with sentinels', () => {
     describe('deleteCharForward (delete key) with sentinels', () => {
         it('removes whole sentinel block when cursor is at opener', () => {
             const buffer = createBuffer(`hello${sentinel1}world`);
-            const cursor = { line: 0, column: 5 }; // at sentinel opener
+            const cursor = { line: 0, column: 5 };
             const result = deleteCharForward(buffer, cursor);
             expect(getTextContent(result.buffer)).toBe('helloworld');
             expect(result.cursor).toEqual({ line: 0, column: 5 });
@@ -124,12 +106,9 @@ describe('TextBuffer with sentinels', () => {
     describe('multiple sentinels', () => {
         it('handles two sentinels with text between', () => {
             const buffer = createBuffer(`${sentinel1}text${sentinel2}`);
-            // Cursor right after sentinel2
             const cursor = { line: 0, column: `${sentinel1}text${sentinel2}`.length };
-            // Move left should jump over sentinel2
             const leftOnce = moveCursor(buffer, cursor, 'left');
             expect(leftOnce).toEqual({ line: 0, column: `${sentinel1}text`.length });
-            // Move left again should be normal (inside "text")
             const leftTwice = moveCursor(buffer, leftOnce, 'left');
             expect(leftTwice).toEqual({ line: 0, column: `${sentinel1}tex`.length });
         });