mirror of
https://github.com/QwenLM/qwen-code.git
synced 2026-04-30 04:30:48 +00:00
fix: add debounce timer for paste event
This commit is contained in:
tanzhenxin
parent
3ad533c50b
commit
b9fd4737c9
3 changed files with 833 additions and 97 deletions
|
|
@ -387,5 +387,698 @@ describe('KeypressContext - Kitty Protocol', () => {
|
|||
}),
|
||||
);
|
||||
});
|
||||
|
||||
describe('paste mode markers', () => {
|
||||
beforeEach(() => {
|
||||
// Force passthrough mode for raw keypress testing
|
||||
vi.stubEnv('PASTE_WORKAROUND', '1');
|
||||
});
|
||||
|
||||
it('should handle complete paste sequence with markers', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
const pastedText = 'pasted content';
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send complete paste sequence: prefix + content + suffix
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from(`\x1b[200~${pastedText}\x1b[201~`));
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
// Should emit a single paste event with the content
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: pastedText,
|
||||
name: '',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle empty paste sequence', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send empty paste sequence: prefix immediately followed by suffix
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('\x1b[200~\x1b[201~'));
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
// Should emit a paste event with empty content
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: '',
|
||||
name: '',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle data before paste markers', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send data before paste sequence
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('before\x1b[200~pasted\x1b[201~'));
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(7); // 6 chars + 1 paste event
|
||||
});
|
||||
|
||||
// Should process 'before' as individual characters
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({ name: 'b' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({ name: 'e' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
3,
|
||||
expect.objectContaining({ name: 'f' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
4,
|
||||
expect.objectContaining({ name: 'o' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
5,
|
||||
expect.objectContaining({ name: 'r' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
6,
|
||||
expect.objectContaining({ name: 'e' }),
|
||||
);
|
||||
|
||||
// Then emit paste event
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
7,
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'pasted',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle data after paste markers', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send paste sequence followed by data
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('\x1b[200~pasted\x1b[201~after'));
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(2); // 1 paste event + 1 paste event for 'after'
|
||||
});
|
||||
|
||||
// Should emit paste event first
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'pasted',
|
||||
}),
|
||||
);
|
||||
|
||||
// Then process 'after' as a paste event (since it's > 2 chars)
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'after',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle complex sequence with multiple paste blocks', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send complex sequence: data + paste1 + data + paste2 + data
|
||||
act(() => {
|
||||
stdin.emit(
|
||||
'data',
|
||||
Buffer.from(
|
||||
'start\x1b[200~first\x1b[201~middle\x1b[200~second\x1b[201~end',
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(14); // Adjusted based on actual behavior
|
||||
});
|
||||
|
||||
// Check the sequence: 'start' (5 chars) + paste1 + 'middle' (6 chars) + paste2 + 'end' (3 chars as paste)
|
||||
let callIndex = 1;
|
||||
|
||||
// 'start'
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 's' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 't' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'a' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'r' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 't' }),
|
||||
);
|
||||
|
||||
// first paste
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'first',
|
||||
}),
|
||||
);
|
||||
|
||||
// 'middle'
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'm' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'i' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'd' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'd' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'l' }),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({ name: 'e' }),
|
||||
);
|
||||
|
||||
// second paste
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'second',
|
||||
}),
|
||||
);
|
||||
|
||||
// 'end' as paste event (since it's > 2 chars)
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
callIndex++,
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'end',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle fragmented paste markers across multiple data events', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send fragmented paste sequence
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('\x1b[200~partial'));
|
||||
stdin.emit('data', Buffer.from(' content\x1b[201~'));
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
// Should combine the fragmented content into a single paste event
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'partial content',
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle multiline content within paste markers', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
const multilineContent = 'line1\nline2\nline3';
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send paste sequence with multiline content
|
||||
act(() => {
|
||||
stdin.emit(
|
||||
'data',
|
||||
Buffer.from(`\x1b[200~${multilineContent}\x1b[201~`),
|
||||
);
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
// Should emit a single paste event with the multiline content
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: multilineContent,
|
||||
}),
|
||||
);
|
||||
});
|
||||
|
||||
it('should handle paste markers split across buffer boundaries', async () => {
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
// Send paste marker split across multiple data events
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('\x1b[20'));
|
||||
stdin.emit('data', Buffer.from('0~content\x1b[2'));
|
||||
stdin.emit('data', Buffer.from('01~'));
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
// Should properly reconstruct and handle the paste sequence
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'content',
|
||||
}),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it('buffers fragmented paste chunks before emitting newlines', () => {
|
||||
vi.useFakeTimers();
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
try {
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('\r'));
|
||||
stdin.emit('data', Buffer.from('rest of paste'));
|
||||
});
|
||||
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(8);
|
||||
});
|
||||
|
||||
// With the current implementation, fragmented data gets combined and
|
||||
// treated as a single paste event due to the buffering mechanism
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
|
||||
// Should be treated as a paste event with the combined content
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: '\rrest of paste',
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Raw keypress pipeline', () => {
|
||||
beforeEach(() => {
|
||||
// Force passthrough mode for raw keypress testing
|
||||
vi.stubEnv('PASTE_WORKAROUND', '1');
|
||||
});
|
||||
|
||||
it('should buffer input data and wait for timeout', () => {
|
||||
vi.useFakeTimers();
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
try {
|
||||
// Send single character
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('a'));
|
||||
});
|
||||
|
||||
// Should not emit immediately
|
||||
expect(keyHandler).not.toHaveBeenCalled();
|
||||
|
||||
// Advance timer to trigger timeout
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(8);
|
||||
});
|
||||
|
||||
// Should emit after timeout
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
name: 'a',
|
||||
sequence: 'a',
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('should concatenate new data and reset timeout', () => {
|
||||
vi.useFakeTimers();
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
try {
|
||||
// Send first chunk
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('hel'));
|
||||
});
|
||||
|
||||
// Advance timer partially
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(4);
|
||||
});
|
||||
|
||||
// Send second chunk before timeout
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('lo'));
|
||||
});
|
||||
|
||||
// Should not have emitted yet
|
||||
expect(keyHandler).not.toHaveBeenCalled();
|
||||
|
||||
// Complete the timeout
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(8);
|
||||
});
|
||||
|
||||
// Should emit as single paste event (multi-character data treated as paste)
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'hello',
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('should flush immediately when buffer exceeds limit', () => {
|
||||
vi.useFakeTimers();
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
try {
|
||||
// Create a large buffer that exceeds the 64 byte limit
|
||||
const largeData = 'x'.repeat(65);
|
||||
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from(largeData));
|
||||
});
|
||||
|
||||
// Should flush immediately without waiting for timeout
|
||||
// Large data gets treated as paste event
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: largeData,
|
||||
}),
|
||||
);
|
||||
|
||||
// Advancing timer should not cause additional calls
|
||||
const callCountBefore = keyHandler.mock.calls.length;
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(8);
|
||||
});
|
||||
|
||||
expect(keyHandler).toHaveBeenCalledTimes(callCountBefore);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('should clear timeout when new data arrives', () => {
|
||||
vi.useFakeTimers();
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
try {
|
||||
// Send first chunk
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('a'));
|
||||
});
|
||||
|
||||
// Advance timer almost to completion
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(7);
|
||||
});
|
||||
|
||||
// Send second chunk (should reset timeout)
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('b'));
|
||||
});
|
||||
|
||||
// Advance by the original remaining time (1ms)
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(1);
|
||||
});
|
||||
|
||||
// Should not have emitted yet because timeout was reset
|
||||
expect(keyHandler).not.toHaveBeenCalled();
|
||||
|
||||
// Complete the new timeout period
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(7);
|
||||
});
|
||||
|
||||
// The current implementation emits 2 individual keypress events for 'a' and 'b'
|
||||
expect(keyHandler).toHaveBeenCalledTimes(2);
|
||||
|
||||
// First event should be 'a', second should be 'b'
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
1,
|
||||
expect.objectContaining({
|
||||
name: 'a',
|
||||
sequence: 'a',
|
||||
paste: false,
|
||||
}),
|
||||
);
|
||||
expect(keyHandler).toHaveBeenNthCalledWith(
|
||||
2,
|
||||
expect.objectContaining({
|
||||
name: 'b',
|
||||
sequence: 'b',
|
||||
paste: false,
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('should handle multiple separate keypress events', () => {
|
||||
vi.useFakeTimers();
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
try {
|
||||
// First keypress
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('a'));
|
||||
});
|
||||
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(8);
|
||||
});
|
||||
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
sequence: 'a',
|
||||
}),
|
||||
);
|
||||
|
||||
keyHandler.mockClear();
|
||||
|
||||
// Second keypress after first completed
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('b'));
|
||||
});
|
||||
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(8);
|
||||
});
|
||||
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
sequence: 'b',
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
|
||||
it('should handle rapid sequential data within buffer limit', () => {
|
||||
vi.useFakeTimers();
|
||||
const keyHandler = vi.fn();
|
||||
|
||||
const { result } = renderHook(() => useKeypressContext(), {
|
||||
wrapper,
|
||||
});
|
||||
|
||||
act(() => {
|
||||
result.current.subscribe(keyHandler);
|
||||
});
|
||||
|
||||
try {
|
||||
// Send multiple small chunks rapidly
|
||||
act(() => {
|
||||
stdin.emit('data', Buffer.from('h'));
|
||||
stdin.emit('data', Buffer.from('e'));
|
||||
stdin.emit('data', Buffer.from('l'));
|
||||
stdin.emit('data', Buffer.from('l'));
|
||||
stdin.emit('data', Buffer.from('o'));
|
||||
});
|
||||
|
||||
// Should not have emitted yet
|
||||
expect(keyHandler).not.toHaveBeenCalled();
|
||||
|
||||
// Complete timeout
|
||||
act(() => {
|
||||
vi.advanceTimersByTime(8);
|
||||
});
|
||||
|
||||
// Should emit as single paste event (multi-character data treated as paste)
|
||||
expect(keyHandler).toHaveBeenCalledTimes(1);
|
||||
expect(keyHandler).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
paste: true,
|
||||
sequence: 'hello',
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
vi.useRealTimers();
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue