ink-prompt 0.2.3 → 0.2.5

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

@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import { BLOCK_OPEN, BLOCK_CLOSE, createBlockMarker, parseBlockMarkers, findBlockMarkerAt, findBlockMarkerBefore, findBlockMarkerAfter, removeBlockMarker, blockMarkerVisualWidth, getBlockPlaceholderText, generateBlockId, } from '../BlockMarker.js';
+describe('generateBlockId', () => {
+    it('generates a non-empty string', () => {
+        const id = generateBlockId();
+        expect(id.length).toBeGreaterThan(0);
+    });
+    it('generates unique IDs', () => {
+        const ids = new Set(Array.from({ length: 100 }, () => generateBlockId()));
+        expect(ids.size).toBe(100);
+    });
+});
+describe('createBlockMarker', () => {
+    it('creates a paste marker', () => {
+        const marker = createBlockMarker('p', 'abc123', 1);
+        expect(marker).toBe(`${BLOCK_OPEN}p:abc123:1${BLOCK_CLOSE}`);
+    });
+    it('creates an image marker', () => {
+        const marker = createBlockMarker('i', 'xyz789', 2);
+        expect(marker).toBe(`${BLOCK_OPEN}i:xyz789:2${BLOCK_CLOSE}`);
+    });
+});
+describe('parseBlockMarkers', () => {
+    it('finds a single paste marker', () => {
+        const text = `hello ${BLOCK_OPEN}p:abc123:1${BLOCK_CLOSE} world`;
+        const markers = parseBlockMarkers(text);
+        expect(markers).toHaveLength(1);
+        expect(markers[0]).toMatchObject({ kind: 'p', id: 'abc123', displayNumber: 1, start: 6, end: 18 });
+    });
+    it('finds a single image marker', () => {
+        const text = `${BLOCK_OPEN}i:xyz789:2${BLOCK_CLOSE}`;
+        const markers = parseBlockMarkers(text);
+        expect(markers).toHaveLength(1);
+        expect(markers[0]).toMatchObject({ kind: 'i', id: 'xyz789', displayNumber: 2, start: 0, end: 12 });
+    });
+    it('finds multiple markers', () => {
+        const text = `${BLOCK_OPEN}p:id1:1${BLOCK_CLOSE}ab${BLOCK_OPEN}i:id2:2${BLOCK_CLOSE}`;
+        const markers = parseBlockMarkers(text);
+        expect(markers).toHaveLength(2);
+        expect(markers[0]).toMatchObject({ kind: 'p', id: 'id1', displayNumber: 1, start: 0 });
+        expect(markers[1]).toMatchObject({ kind: 'i', id: 'id2', displayNumber: 2 });
+    });
+    it('returns empty array for text without markers', () => {
+        expect(parseBlockMarkers('plain text')).toEqual([]);
+    });
+    it('returns empty array for empty text', () => {
+        expect(parseBlockMarkers('')).toEqual([]);
+    });
+    it('skips malformed markers', () => {
+        const text = `${BLOCK_OPEN}bad${BLOCK_CLOSE}`;
+        expect(parseBlockMarkers(text)).toEqual([]);
+    });
+    it('skips markers with unknown kind', () => {
+        const text = `${BLOCK_OPEN}x:abc:1${BLOCK_CLOSE}`;
+        expect(parseBlockMarkers(text)).toEqual([]);
+    });
+});
+describe('findBlockMarkerAt', () => {
+    it('finds marker containing the offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const result = findBlockMarkerAt(text, 2);
+        expect(result).toMatchObject({ kind: 'p', id: 'id', displayNumber: 1 });
+    });
+    it('returns null for offset at marker start', () => {
+        const text = `${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}`;
+        expect(findBlockMarkerAt(text, 0)).toBeNull();
+    });
+    it('returns null for offset at marker end', () => {
+        const text = `${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}`;
+        const end = text.length;
+        expect(findBlockMarkerAt(text, end)).toBeNull();
+    });
+    it('returns null outside markers', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        expect(findBlockMarkerAt(text, 0)).toBeNull();
+        expect(findBlockMarkerAt(text, text.length - 1)).toBeNull();
+    });
+});
+describe('findBlockMarkerBefore', () => {
+    it('finds marker ending at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const end = text.indexOf(BLOCK_CLOSE) + 1;
+        const result = findBlockMarkerBefore(text, end);
+        expect(result).toMatchObject({ kind: 'p', id: 'id' });
+    });
+    it('returns null when no marker ends at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        expect(findBlockMarkerBefore(text, 1)).toBeNull();
+    });
+});
+describe('findBlockMarkerAfter', () => {
+    it('finds marker starting at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const start = text.indexOf(BLOCK_OPEN);
+        const result = findBlockMarkerAfter(text, start);
+        expect(result).toMatchObject({ kind: 'p', id: 'id' });
+    });
+    it('returns null when no marker starts at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        expect(findBlockMarkerAfter(text, 0)).toBeNull();
+        expect(findBlockMarkerAfter(text, 2)).toBeNull();
+    });
+});
+describe('removeBlockMarker', () => {
+    it('removes marker at offset', () => {
+        const text = `a${BLOCK_OPEN}p:id:1${BLOCK_CLOSE}b`;
+        const result = removeBlockMarker(text, 2);
+        expect(result).toBe('ab');
+    });
+    it('returns original text if no marker at offset', () => {
+        const text = 'abc';
+        expect(removeBlockMarker(text, 1)).toBe('abc');
+    });
+});
+describe('getBlockPlaceholderText', () => {
+    it('formats image display text', () => {
+        expect(getBlockPlaceholderText('i', 1)).toBe('[Pasted Image #1]');
+        expect(getBlockPlaceholderText('i', 42)).toBe('[Pasted Image #42]');
+    });
+    it('formats paste display text', () => {
+        expect(getBlockPlaceholderText('p', 1)).toBe('[Paste text #1]');
+        expect(getBlockPlaceholderText('p', 5)).toBe('[Paste text #5]');
+    });
+});
+describe('blockMarkerVisualWidth', () => {
+    it('returns correct width', () => {
+        expect(blockMarkerVisualWidth(1)).toBe('[Pasted Image #1]'.length);
+        expect(blockMarkerVisualWidth(100)).toBe('[Pasted Image #100]'.length);
+    });
+});

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__/KeyHandler.test.js

@@ -289,6 +289,24 @@ describe('KeyHandler', () => {
             expect(actions.newLine).not.toHaveBeenCalled();
             expect(actions.submit).not.toHaveBeenCalled();
         });
+        it('handles Shift+Enter as newline', () => {
+            buffer = { lines: ['hello'] };
+            handleKey({ shift: true, return: true }, '', buffer, actions);
+            expect(actions.newLine).toHaveBeenCalledTimes(1);
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
+        it('handles ESC+CR raw sequence (Shift+Enter) as newline', () => {
+            buffer = { lines: ['hello'] };
+            handleKey({ meta: true, return: true }, '', buffer, actions, undefined, '\x1b\r');
+            expect(actions.newLine).toHaveBeenCalledTimes(1);
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
+        it('handles kitty Shift+Enter CSI u sequence as newline', () => {
+            buffer = { lines: ['hello'] };
+            handleKey({}, '', buffer, actions, undefined, '\x1b[13;2u');
+            expect(actions.newLine).toHaveBeenCalledTimes(1);
+            expect(actions.submit).not.toHaveBeenCalled();
+        });
         it('handles Enter as newline if line ends with backslash (multiple lines)', () => {
             const cursor = { line: 1, column: 7 };
             buffer = { lines: ['first', 'second\\'] };