@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc1

package/dist/src/ui/components/shared/text-buffer.test.js

@@ -5,7 +5,8 @@
  */
 import { describe, it, expect, beforeEach } from 'vitest';
 import stripAnsi from 'strip-ansi';
-import { renderHook, act } from '@testing-library/react';
+import { act } from 'react';
+import { renderHook } from '../../../test-utils/render.js';
 import { useTextBuffer, offsetToLogicalPos, logicalPosToOffset, textBufferReducer, findWordEndInLine, findNextWordStartInLine, isWordCharStrict, } from './text-buffer.js';
 import { cpLen } from '../../utils/textUtils.js';
 const defaultVisualLayout = {
@@ -76,6 +77,40 @@ describe('textBufferReducer', () => {
             expect(state.cursorCol).toBe(0);
         });
     });
+    describe('insert action with options', () => {
+        it('should filter input using inputFilter option', () => {
+            const action = { type: 'insert', payload: 'a1b2c3' };
+            const options = {
+                inputFilter: (text) => text.replace(/[0-9]/g, ''),
+            };
+            const state = textBufferReducer(initialState, action, options);
+            expect(state.lines).toEqual(['abc']);
+            expect(state.cursorCol).toBe(3);
+        });
+        it('should strip newlines when singleLine option is true', () => {
+            const action = {
+                type: 'insert',
+                payload: 'hello\nworld',
+            };
+            const options = { singleLine: true };
+            const state = textBufferReducer(initialState, action, options);
+            expect(state.lines).toEqual(['helloworld']);
+            expect(state.cursorCol).toBe(10);
+        });
+        it('should apply both inputFilter and singleLine options', () => {
+            const action = {
+                type: 'insert',
+                payload: 'h\ne\nl\nl\no\n1\n2\n3',
+            };
+            const options = {
+                singleLine: true,
+                inputFilter: (text) => text.replace(/[0-9]/g, ''),
+            };
+            const state = textBufferReducer(initialState, action, options);
+            expect(state.lines).toEqual(['hello']);
+            expect(state.cursorCol).toBe(5);
+        });
+    });
     describe('backspace action', () => {
         it('should remove a character', () => {
             const stateWithText = {
@@ -153,41 +188,38 @@ describe('textBufferReducer', () => {
         });
     });
     describe('delete_word_left action', () => {
-        it('should delete a simple word', () => {
-            const stateWithText = {
-                ...initialState,
-                lines: ['hello world'],
-                cursorRow: 0,
+        const createSingleLineState = (text, col) => ({
+            ...initialState,
+            lines: [text],
+            cursorRow: 0,
+            cursorCol: col,
+        });
+        it.each([
+            {
+                input: 'hello world',
                 cursorCol: 11,
-            };
-            const action = { type: 'delete_word_left' };
-            const state = textBufferReducer(stateWithText, action);
-            expect(state.lines).toEqual(['hello ']);
-            expect(state.cursorCol).toBe(6);
-        });
-        it('should delete a path segment', () => {
-            const stateWithText = {
-                ...initialState,
-                lines: ['path/to/file'],
-                cursorRow: 0,
+                expectedLines: ['hello '],
+                expectedCol: 6,
+                desc: 'simple word',
+            },
+            {
+                input: 'path/to/file',
                 cursorCol: 12,
-            };
-            const action = { type: 'delete_word_left' };
-            const state = textBufferReducer(stateWithText, action);
-            expect(state.lines).toEqual(['path/to/']);
-            expect(state.cursorCol).toBe(8);
-        });
-        it('should delete variable_name parts', () => {
-            const stateWithText = {
-                ...initialState,
-                lines: ['variable_name'],
-                cursorRow: 0,
+                expectedLines: ['path/to/'],
+                expectedCol: 8,
+                desc: 'path segment',
+            },
+            {
+                input: 'variable_name',
                 cursorCol: 13,
-            };
-            const action = { type: 'delete_word_left' };
-            const state = textBufferReducer(stateWithText, action);
-            expect(state.lines).toEqual(['variable_']);
-            expect(state.cursorCol).toBe(9);
+                expectedLines: ['variable_'],
+                expectedCol: 9,
+                desc: 'variable_name parts',
+            },
+        ])('should delete $desc', ({ input, cursorCol, expectedLines, expectedCol }) => {
+            const state = textBufferReducer(createSingleLineState(input, cursorCol), { type: 'delete_word_left' });
+            expect(state.lines).toEqual(expectedLines);
+            expect(state.cursorCol).toBe(expectedCol);
         });
         it('should act like backspace at the beginning of a line', () => {
             const stateWithText = {
@@ -196,51 +228,55 @@ describe('textBufferReducer', () => {
                 cursorRow: 1,
                 cursorCol: 0,
             };
-            const action = { type: 'delete_word_left' };
-            const state = textBufferReducer(stateWithText, action);
+            const state = textBufferReducer(stateWithText, {
+                type: 'delete_word_left',
+            });
             expect(state.lines).toEqual(['helloworld']);
             expect(state.cursorRow).toBe(0);
             expect(state.cursorCol).toBe(5);
         });
     });
     describe('delete_word_right action', () => {
-        it('should delete a simple word', () => {
-            const stateWithText = {
-                ...initialState,
-                lines: ['hello world'],
-                cursorRow: 0,
+        const createSingleLineState = (text, col) => ({
+            ...initialState,
+            lines: [text],
+            cursorRow: 0,
+            cursorCol: col,
+        });
+        it.each([
+            {
+                input: 'hello world',
                 cursorCol: 0,
-            };
-            const action = { type: 'delete_word_right' };
-            const state = textBufferReducer(stateWithText, action);
-            expect(state.lines).toEqual(['world']);
-            expect(state.cursorCol).toBe(0);
-        });
-        it('should delete a path segment', () => {
+                expectedLines: ['world'],
+                expectedCol: 0,
+                desc: 'simple word',
+            },
+            {
+                input: 'variable_name',
+                cursorCol: 0,
+                expectedLines: ['_name'],
+                expectedCol: 0,
+                desc: 'variable_name parts',
+            },
+        ])('should delete $desc', ({ input, cursorCol, expectedLines, expectedCol }) => {
+            const state = textBufferReducer(createSingleLineState(input, cursorCol), { type: 'delete_word_right' });
+            expect(state.lines).toEqual(expectedLines);
+            expect(state.cursorCol).toBe(expectedCol);
+        });
+        it('should delete path segments progressively', () => {
             const stateWithText = {
                 ...initialState,
                 lines: ['path/to/file'],
                 cursorRow: 0,
                 cursorCol: 0,
             };
-            const action = { type: 'delete_word_right' };
-            let state = textBufferReducer(stateWithText, action);
+            let state = textBufferReducer(stateWithText, {
+                type: 'delete_word_right',
+            });
             expect(state.lines).toEqual(['/to/file']);
-            state = textBufferReducer(state, action);
+            state = textBufferReducer(state, { type: 'delete_word_right' });
             expect(state.lines).toEqual(['to/file']);
         });
-        it('should delete variable_name parts', () => {
-            const stateWithText = {
-                ...initialState,
-                lines: ['variable_name'],
-                cursorRow: 0,
-                cursorCol: 0,
-            };
-            const action = { type: 'delete_word_right' };
-            const state = textBufferReducer(stateWithText, action);
-            expect(state.lines).toEqual(['_name']);
-            expect(state.cursorCol).toBe(0);
-        });
         it('should act like delete at the end of a line', () => {
             const stateWithText = {
                 ...initialState,
@@ -248,15 +284,15 @@ describe('textBufferReducer', () => {
                 cursorRow: 0,
                 cursorCol: 5,
             };
-            const action = { type: 'delete_word_right' };
-            const state = textBufferReducer(stateWithText, action);
+            const state = textBufferReducer(stateWithText, {
+                type: 'delete_word_right',
+            });
             expect(state.lines).toEqual(['helloworld']);
             expect(state.cursorRow).toBe(0);
             expect(state.cursorCol).toBe(5);
         });
     });
 });
-// Helper to get the state from the hook
 const getBufferState = (result) => {
     expect(result.current).toHaveOnlyValidCharacters();
     return {
@@ -1094,71 +1130,46 @@ Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots
         });
     });
     describe('Input Sanitization', () => {
-        it('should strip ANSI escape codes from input', () => {
-            const { result } = renderHook(() => useTextBuffer({ viewport, isValidPath: () => false }));
-            const textWithAnsi = '\x1B[31mHello\x1B[0m \x1B[32mWorld\x1B[0m';
-            act(() => result.current.handleInput({
-                name: '',
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: textWithAnsi,
-            }));
-            expect(getBufferState(result).text).toBe('Hello World');
-        });
-        it('should strip control characters from input', () => {
+        const createInput = (sequence) => ({
+            name: '',
+            ctrl: false,
+            meta: false,
+            shift: false,
+            paste: false,
+            sequence,
+        });
+        it.each([
+            {
+                input: '\x1B[31mHello\x1B[0m \x1B[32mWorld\x1B[0m',
+                expected: 'Hello World',
+                desc: 'ANSI escape codes',
+            },
+            {
+                input: 'H\x07e\x08l\x0Bl\x0Co',
+                expected: 'Hello',
+                desc: 'control characters',
+            },
+            {
+                input: '\u001B[4mH\u001B[0mello',
+                expected: 'Hello',
+                desc: 'mixed ANSI and control characters',
+            },
+            {
+                input: '\u001B[4mPasted\u001B[4m Text',
+                expected: 'Pasted Text',
+                desc: 'pasted text with ANSI',
+            },
+        ])('should strip $desc from input', ({ input, expected }) => {
             const { result } = renderHook(() => useTextBuffer({ viewport, isValidPath: () => false }));
-            const textWithControlChars = 'H\x07e\x08l\x0Bl\x0Co'; // BELL, BACKSPACE, VT, FF
-            act(() => result.current.handleInput({
-                name: '',
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: textWithControlChars,
-            }));
-            expect(getBufferState(result).text).toBe('Hello');
-        });
-        it('should strip mixed ANSI and control characters from input', () => {
-            const { result } = renderHook(() => useTextBuffer({ viewport, isValidPath: () => false }));
-            const textWithMixed = '\u001B[4mH\u001B[0mello';
-            act(() => result.current.handleInput({
-                name: '',
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: textWithMixed,
-            }));
-            expect(getBufferState(result).text).toBe('Hello');
+            act(() => result.current.handleInput(createInput(input)));
+            expect(getBufferState(result).text).toBe(expected);
         });
         it('should not strip standard characters or newlines', () => {
             const { result } = renderHook(() => useTextBuffer({ viewport, isValidPath: () => false }));
             const validText = 'Hello World\nThis is a test.';
-            act(() => result.current.handleInput({
-                name: '',
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: validText,
-            }));
+            act(() => result.current.handleInput(createInput(validText)));
             expect(getBufferState(result).text).toBe(validText);
         });
-        it('should sanitize pasted text via handleInput', () => {
-            const { result } = renderHook(() => useTextBuffer({ viewport, isValidPath: () => false }));
-            const pastedText = '\u001B[4mPasted\u001B[4m Text';
-            act(() => result.current.handleInput({
-                name: '',
-                ctrl: false,
-                meta: false,
-                shift: false,
-                paste: false,
-                sequence: pastedText,
-            }));
-            expect(getBufferState(result).text).toBe('Pasted Text');
-        });
         it('should sanitize large text (>5000 chars) and strip unsafe characters', () => {
             const { result } = renderHook(() => useTextBuffer({ viewport, isValidPath: () => false }));
             const unsafeChars = '\x07\x08\x0B\x0C';
@@ -1218,6 +1229,55 @@ Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots
             expect(getBufferState(result).text).toBe(emojis);
         });
     });
+    describe('inputFilter', () => {
+        it('should filter input based on the provided filter function', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                inputFilter: (text) => text.replace(/[^0-9]/g, ''),
+            }));
+            act(() => result.current.insert('a1b2c3'));
+            expect(getBufferState(result).text).toBe('123');
+        });
+        it('should handle empty result from filter', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                inputFilter: (text) => text.replace(/[^0-9]/g, ''),
+            }));
+            act(() => result.current.insert('abc'));
+            expect(getBufferState(result).text).toBe('');
+        });
+        it('should filter pasted text', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                inputFilter: (text) => text.toUpperCase(),
+            }));
+            act(() => result.current.insert('hello', { paste: true }));
+            expect(getBufferState(result).text).toBe('HELLO');
+        });
+        it('should not filter newlines if they are allowed by the filter', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                inputFilter: (text) => text, // Allow everything including newlines
+            }));
+            act(() => result.current.insert('a\nb'));
+            // The insert function splits by newline and inserts separately if it detects them.
+            // If the filter allows them, they should be handled correctly by the subsequent logic in insert.
+            expect(getBufferState(result).text).toBe('a\nb');
+        });
+        it('should filter before newline check in insert', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                inputFilter: (text) => text.replace(/\n/g, ''), // Filter out newlines
+            }));
+            act(() => result.current.insert('a\nb'));
+            expect(getBufferState(result).text).toBe('ab');
+        });
+    });
     describe('stripAnsi', () => {
         it('should correctly strip ANSI escape codes', () => {
             const textWithAnsi = '\x1B[31mHello\x1B[0m World';
@@ -1269,88 +1329,212 @@ Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots
             expect(getBufferState(result).text).toBe('hello world');
         });
     });
+    describe('singleLine mode', () => {
+        it('should not insert a newline character when singleLine is true', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                singleLine: true,
+            }));
+            act(() => result.current.insert('\n'));
+            const state = getBufferState(result);
+            expect(state.text).toBe('');
+            expect(state.lines).toEqual(['']);
+        });
+        it('should not create a new line when newline() is called and singleLine is true', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                initialText: 'ab',
+                viewport,
+                isValidPath: () => false,
+                singleLine: true,
+            }));
+            act(() => result.current.move('end')); // cursor at [0,2]
+            act(() => result.current.newline());
+            const state = getBufferState(result);
+            expect(state.text).toBe('ab');
+            expect(state.lines).toEqual(['ab']);
+            expect(state.cursor).toEqual([0, 2]);
+        });
+        it('should not handle "Enter" key as newline when singleLine is true', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                singleLine: true,
+            }));
+            act(() => result.current.handleInput({
+                name: 'return',
+                ctrl: false,
+                meta: false,
+                shift: false,
+                paste: false,
+                sequence: '\r',
+            }));
+            expect(getBufferState(result).lines).toEqual(['']);
+        });
+        it('should strip newlines from pasted text when singleLine is true', () => {
+            const { result } = renderHook(() => useTextBuffer({
+                viewport,
+                isValidPath: () => false,
+                singleLine: true,
+            }));
+            act(() => result.current.insert('hello\nworld', { paste: true }));
+            const state = getBufferState(result);
+            expect(state.text).toBe('helloworld');
+            expect(state.lines).toEqual(['helloworld']);
+        });
+    });
 });
 describe('offsetToLogicalPos', () => {
-    it('should return [0,0] for offset 0', () => {
-        expect(offsetToLogicalPos('any text', 0)).toEqual([0, 0]);
-    });
-    it('should handle single line text', () => {
-        const text = 'hello';
-        expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start
-        expect(offsetToLogicalPos(text, 2)).toEqual([0, 2]); // Middle 'l'
-        expect(offsetToLogicalPos(text, 5)).toEqual([0, 5]); // End
-        expect(offsetToLogicalPos(text, 10)).toEqual([0, 5]); // Beyond end
+    it.each([
+        { text: 'any text', offset: 0, expected: [0, 0], desc: 'offset 0' },
+        { text: 'hello', offset: 0, expected: [0, 0], desc: 'single line start' },
+        { text: 'hello', offset: 2, expected: [0, 2], desc: 'single line middle' },
+        { text: 'hello', offset: 5, expected: [0, 5], desc: 'single line end' },
+        { text: 'hello', offset: 10, expected: [0, 5], desc: 'beyond end clamps' },
+        {
+            text: 'a\n\nc',
+            offset: 0,
+            expected: [0, 0],
+            desc: 'empty lines - first char',
+        },
+        {
+            text: 'a\n\nc',
+            offset: 1,
+            expected: [0, 1],
+            desc: 'empty lines - end of first',
+        },
+        {
+            text: 'a\n\nc',
+            offset: 2,
+            expected: [1, 0],
+            desc: 'empty lines - empty line',
+        },
+        {
+            text: 'a\n\nc',
+            offset: 3,
+            expected: [2, 0],
+            desc: 'empty lines - last line start',
+        },
+        {
+            text: 'a\n\nc',
+            offset: 4,
+            expected: [2, 1],
+            desc: 'empty lines - last line end',
+        },
+        {
+            text: 'hello\n',
+            offset: 5,
+            expected: [0, 5],
+            desc: 'newline end - before newline',
+        },
+        {
+            text: 'hello\n',
+            offset: 6,
+            expected: [1, 0],
+            desc: 'newline end - after newline',
+        },
+        {
+            text: 'hello\n',
+            offset: 7,
+            expected: [1, 0],
+            desc: 'newline end - beyond',
+        },
+        {
+            text: '\nhello',
+            offset: 0,
+            expected: [0, 0],
+            desc: 'newline start - first line',
+        },
+        {
+            text: '\nhello',
+            offset: 1,
+            expected: [1, 0],
+            desc: 'newline start - second line',
+        },
+        {
+            text: '\nhello',
+            offset: 3,
+            expected: [1, 2],
+            desc: 'newline start - middle of second',
+        },
+        { text: '', offset: 0, expected: [0, 0], desc: 'empty string at 0' },
+        { text: '', offset: 5, expected: [0, 0], desc: 'empty string beyond' },
+        {
+            text: '你好\n世界',
+            offset: 0,
+            expected: [0, 0],
+            desc: 'unicode - start',
+        },
+        {
+            text: '你好\n世界',
+            offset: 1,
+            expected: [0, 1],
+            desc: 'unicode - after first char',
+        },
+        {
+            text: '你好\n世界',
+            offset: 2,
+            expected: [0, 2],
+            desc: 'unicode - end first line',
+        },
+        {
+            text: '你好\n世界',
+            offset: 3,
+            expected: [1, 0],
+            desc: 'unicode - second line start',
+        },
+        {
+            text: '你好\n世界',
+            offset: 4,
+            expected: [1, 1],
+            desc: 'unicode - second line middle',
+        },
+        {
+            text: '你好\n世界',
+            offset: 5,
+            expected: [1, 2],
+            desc: 'unicode - second line end',
+        },
+        {
+            text: '你好\n世界',
+            offset: 6,
+            expected: [1, 2],
+            desc: 'unicode - beyond',
+        },
+        {
+            text: 'abc\ndef',
+            offset: 3,
+            expected: [0, 3],
+            desc: 'at newline - end of line',
+        },
+        {
+            text: 'abc\ndef',
+            offset: 4,
+            expected: [1, 0],
+            desc: 'at newline - after newline',
+        },
+        { text: '🐶🐱', offset: 0, expected: [0, 0], desc: 'emoji - start' },
+        { text: '🐶🐱', offset: 1, expected: [0, 1], desc: 'emoji - middle' },
+        { text: '🐶🐱', offset: 2, expected: [0, 2], desc: 'emoji - end' },
+    ])('should handle $desc', ({ text, offset, expected }) => {
+        expect(offsetToLogicalPos(text, offset)).toEqual(expected);
     });
-    it('should handle multi-line text', () => {
+    describe('multi-line text', () => {
         const text = 'hello\nworld\n123';
-        // "hello" (5) + \n (1) + "world" (5) + \n (1) + "123" (3)
-        // h e l l o \n w o r l d \n 1 2 3
-        // 0 1 2 3 4  5  6 7 8 9 0  1  2 3 4
-        // Line 0: "hello" (length 5)
-        expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start of 'hello'
-        expect(offsetToLogicalPos(text, 3)).toEqual([0, 3]); // 'l' in 'hello'
-        expect(offsetToLogicalPos(text, 5)).toEqual([0, 5]); // End of 'hello' (before \n)
-        // Line 1: "world" (length 5)
-        expect(offsetToLogicalPos(text, 6)).toEqual([1, 0]); // Start of 'world' (after \n)
-        expect(offsetToLogicalPos(text, 8)).toEqual([1, 2]); // 'r' in 'world'
-        expect(offsetToLogicalPos(text, 11)).toEqual([1, 5]); // End of 'world' (before \n)
-        // Line 2: "123" (length 3)
-        expect(offsetToLogicalPos(text, 12)).toEqual([2, 0]); // Start of '123' (after \n)
-        expect(offsetToLogicalPos(text, 13)).toEqual([2, 1]); // '2' in '123'
-        expect(offsetToLogicalPos(text, 15)).toEqual([2, 3]); // End of '123'
-        expect(offsetToLogicalPos(text, 20)).toEqual([2, 3]); // Beyond end of text
-    });
-    it('should handle empty lines', () => {
-        const text = 'a\n\nc'; // "a" (1) + \n (1) + "" (0) + \n (1) + "c" (1)
-        expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // 'a'
-        expect(offsetToLogicalPos(text, 1)).toEqual([0, 1]); // End of 'a'
-        expect(offsetToLogicalPos(text, 2)).toEqual([1, 0]); // Start of empty line
-        expect(offsetToLogicalPos(text, 3)).toEqual([2, 0]); // Start of 'c'
-        expect(offsetToLogicalPos(text, 4)).toEqual([2, 1]); // End of 'c'
-    });
-    it('should handle text ending with a newline', () => {
-        const text = 'hello\n'; // "hello" (5) + \n (1)
-        expect(offsetToLogicalPos(text, 5)).toEqual([0, 5]); // End of 'hello'
-        expect(offsetToLogicalPos(text, 6)).toEqual([1, 0]); // Position on the new empty line after
-        expect(offsetToLogicalPos(text, 7)).toEqual([1, 0]); // Still on the new empty line
-    });
-    it('should handle text starting with a newline', () => {
-        const text = '\nhello'; // "" (0) + \n (1) + "hello" (5)
-        expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start of first empty line
-        expect(offsetToLogicalPos(text, 1)).toEqual([1, 0]); // Start of 'hello'
-        expect(offsetToLogicalPos(text, 3)).toEqual([1, 2]); // 'l' in 'hello'
-    });
-    it('should handle empty string input', () => {
-        expect(offsetToLogicalPos('', 0)).toEqual([0, 0]);
-        expect(offsetToLogicalPos('', 5)).toEqual([0, 0]);
-    });
-    it('should handle multi-byte unicode characters correctly', () => {
-        const text = '你好\n世界'; // "你好" (2 chars) + \n (1) + "世界" (2 chars)
-        // Total "code points" for offset calculation: 2 + 1 + 2 = 5
-        expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]); // Start of '你好'
-        expect(offsetToLogicalPos(text, 1)).toEqual([0, 1]); // After '你', before '好'
-        expect(offsetToLogicalPos(text, 2)).toEqual([0, 2]); // End of '你好'
-        expect(offsetToLogicalPos(text, 3)).toEqual([1, 0]); // Start of '世界'
-        expect(offsetToLogicalPos(text, 4)).toEqual([1, 1]); // After '世', before '界'
-        expect(offsetToLogicalPos(text, 5)).toEqual([1, 2]); // End of '世界'
-        expect(offsetToLogicalPos(text, 6)).toEqual([1, 2]); // Beyond end
-    });
-    it('should handle offset exactly at newline character', () => {
-        const text = 'abc\ndef';
-        // a b c \n d e f
-        // 0 1 2  3  4 5 6
-        expect(offsetToLogicalPos(text, 3)).toEqual([0, 3]); // End of 'abc'
-        // The next character is the newline, so an offset of 4 means the start of the next line.
-        expect(offsetToLogicalPos(text, 4)).toEqual([1, 0]); // Start of 'def'
-    });
-    it('should handle offset in the middle of a multi-byte character (should place at start of that char)', () => {
-        // This scenario is tricky as "offset" is usually character-based.
-        // Assuming cpLen and related logic handles this by treating multi-byte as one unit.
-        // The current implementation of offsetToLogicalPos uses cpLen, so it should be code-point aware.
-        const text = '🐶🐱'; // 2 code points
-        expect(offsetToLogicalPos(text, 0)).toEqual([0, 0]);
-        expect(offsetToLogicalPos(text, 1)).toEqual([0, 1]); // After 🐶
-        expect(offsetToLogicalPos(text, 2)).toEqual([0, 2]); // After 🐱
+        it.each([
+            { offset: 0, expected: [0, 0], desc: 'start of first line' },
+            { offset: 3, expected: [0, 3], desc: 'middle of first line' },
+            { offset: 5, expected: [0, 5], desc: 'end of first line' },
+            { offset: 6, expected: [1, 0], desc: 'start of second line' },
+            { offset: 8, expected: [1, 2], desc: 'middle of second line' },
+            { offset: 11, expected: [1, 5], desc: 'end of second line' },
+            { offset: 12, expected: [2, 0], desc: 'start of third line' },
+            { offset: 13, expected: [2, 1], desc: 'middle of third line' },
+            { offset: 15, expected: [2, 3], desc: 'end of third line' },
+            { offset: 20, expected: [2, 3], desc: 'beyond end' },
+        ])('should return $expected for $desc (offset $offset)', ({ offset, expected }) => {
+            expect(offsetToLogicalPos(text, offset)).toEqual(expected);
+        });
     });
 });
 describe('logicalPosToOffset', () => {
@@ -1400,7 +1584,6 @@ describe('logicalPosToOffset', () => {
         expect(logicalPosToOffset(lines, 5, 10)).toBe(5); // Clamps to end of last line
     });
 });
-// Helper to create state for reducer tests
 const createTestState = (lines, cursorRow, cursorCol, viewportWidth = 80) => {
     const text = lines.join('\n');
     let state = textBufferReducer(initialState, {