fss-link 1.0.40 → 1.0.45

package/dist/ui/hooks/useInputHistory.test.ts

@@ -0,0 +1,261 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { act, renderHook } from '@testing-library/react';
+import { useInputHistory } from './useInputHistory.js';
+
+describe('useInputHistory', () => {
+  const mockOnSubmit = vi.fn();
+  const mockOnChange = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const userMessages = ['message 1', 'message 2', 'message 3'];
+
+  it('should initialize with historyIndex -1 and empty originalQueryBeforeNav', () => {
+    const { result } = renderHook(() =>
+      useInputHistory({
+        userMessages: [],
+        onSubmit: mockOnSubmit,
+        isActive: true,
+        currentQuery: '',
+        onChange: mockOnChange,
+      }),
+    );
+
+    // Internal state is not directly testable, but we can infer from behavior.
+    // Attempting to navigate down should do nothing if historyIndex is -1.
+    act(() => {
+      result.current.navigateDown();
+    });
+    expect(mockOnChange).not.toHaveBeenCalled();
+  });
+
+  describe('handleSubmit', () => {
+    it('should call onSubmit with trimmed value and reset history', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: '  test query  ',
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.handleSubmit('  submit value  ');
+      });
+
+      expect(mockOnSubmit).toHaveBeenCalledWith('submit value');
+      // Check if history is reset (e.g., by trying to navigate down)
+      act(() => {
+        result.current.navigateDown();
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should not call onSubmit if value is empty after trimming', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: '',
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.handleSubmit('   ');
+      });
+
+      expect(mockOnSubmit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('navigateUp', () => {
+    it('should not navigate if isActive is false', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: false,
+          currentQuery: 'current',
+          onChange: mockOnChange,
+        }),
+      );
+      act(() => {
+        const navigated = result.current.navigateUp();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should not navigate if userMessages is empty', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages: [],
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: 'current',
+          onChange: mockOnChange,
+        }),
+      );
+      act(() => {
+        const navigated = result.current.navigateUp();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should call onChange with the last message when navigating up from initial state', () => {
+      const currentQuery = 'current query';
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery,
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp();
+      });
+
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]); // Last message
+    });
+
+    it('should store currentQuery as originalQueryBeforeNav on first navigateUp', () => {
+      const currentQuery = 'original user input';
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery,
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp(); // historyIndex becomes 0
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]);
+
+      // Navigate down to restore original query
+      act(() => {
+        result.current.navigateDown(); // historyIndex becomes -1
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(currentQuery);
+    });
+
+    it('should navigate through history messages on subsequent navigateUp calls', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: '',
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 3'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]);
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 2'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[1]);
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 1'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[0]);
+    });
+  });
+
+  describe('navigateDown', () => {
+    it('should not navigate if isActive is false', () => {
+      const initialProps = {
+        userMessages,
+        onSubmit: mockOnSubmit,
+        isActive: true, // Start active to allow setup navigation
+        currentQuery: 'current',
+        onChange: mockOnChange,
+      };
+      const { result, rerender } = renderHook(
+        (props) => useInputHistory(props),
+        {
+          initialProps,
+        },
+      );
+
+      // First navigate up to have something in history
+      act(() => {
+        result.current.navigateUp();
+      });
+      mockOnChange.mockClear(); // Clear calls from setup
+
+      // Set isActive to false for the actual test
+      rerender({ ...initialProps, isActive: false });
+
+      act(() => {
+        const navigated = result.current.navigateDown();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should not navigate if historyIndex is -1 (not in history navigation)', () => {
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: 'current',
+          onChange: mockOnChange,
+        }),
+      );
+      act(() => {
+        const navigated = result.current.navigateDown();
+        expect(navigated).toBe(false);
+      });
+      expect(mockOnChange).not.toHaveBeenCalled();
+    });
+
+    it('should restore originalQueryBeforeNav when navigating down to initial state', () => {
+      const originalQuery = 'my original input';
+      const { result } = renderHook(() =>
+        useInputHistory({
+          userMessages,
+          onSubmit: mockOnSubmit,
+          isActive: true,
+          currentQuery: originalQuery,
+          onChange: mockOnChange,
+        }),
+      );
+
+      act(() => {
+        result.current.navigateUp(); // Navigates to 'message 3', stores 'originalQuery'
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(userMessages[2]);
+      mockOnChange.mockClear();
+
+      act(() => {
+        result.current.navigateDown(); // Navigates back to original query
+      });
+      expect(mockOnChange).toHaveBeenCalledWith(originalQuery);
+    });
+  });
+});

package/dist/ui/hooks/useInputHistory.ts

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useState, useCallback } from 'react';
+
+interface UseInputHistoryProps {
+  userMessages: readonly string[];
+  onSubmit: (value: string) => void;
+  isActive: boolean;
+  currentQuery: string; // Renamed from query to avoid confusion
+  onChange: (value: string) => void;
+}
+
+export interface UseInputHistoryReturn {
+  handleSubmit: (value: string) => void;
+  navigateUp: () => boolean;
+  navigateDown: () => boolean;
+}
+
+export function useInputHistory({
+  userMessages,
+  onSubmit,
+  isActive,
+  currentQuery,
+  onChange,
+}: UseInputHistoryProps): UseInputHistoryReturn {
+  const [historyIndex, setHistoryIndex] = useState<number>(-1);
+  const [originalQueryBeforeNav, setOriginalQueryBeforeNav] =
+    useState<string>('');
+
+  const resetHistoryNav = useCallback(() => {
+    setHistoryIndex(-1);
+    setOriginalQueryBeforeNav('');
+  }, []);
+
+  const handleSubmit = useCallback(
+    (value: string) => {
+      const trimmedValue = value.trim();
+      if (trimmedValue) {
+        onSubmit(trimmedValue); // Parent handles clearing the query
+      }
+      resetHistoryNav();
+    },
+    [onSubmit, resetHistoryNav],
+  );
+
+  const navigateUp = useCallback(() => {
+    if (!isActive) return false;
+    if (userMessages.length === 0) return false;
+
+    let nextIndex = historyIndex;
+    if (historyIndex === -1) {
+      // Store the current query from the parent before navigating
+      setOriginalQueryBeforeNav(currentQuery);
+      nextIndex = 0;
+    } else if (historyIndex < userMessages.length - 1) {
+      nextIndex = historyIndex + 1;
+    } else {
+      return false; // Already at the oldest message
+    }
+
+    if (nextIndex !== historyIndex) {
+      setHistoryIndex(nextIndex);
+      const newValue = userMessages[userMessages.length - 1 - nextIndex];
+      onChange(newValue);
+      return true;
+    }
+    return false;
+  }, [
+    historyIndex,
+    setHistoryIndex,
+    onChange,
+    userMessages,
+    isActive,
+    currentQuery, // Use currentQuery from props
+    setOriginalQueryBeforeNav,
+  ]);
+
+  const navigateDown = useCallback(() => {
+    if (!isActive) return false;
+    if (historyIndex === -1) return false; // Not currently navigating history
+
+    const nextIndex = historyIndex - 1;
+    setHistoryIndex(nextIndex);
+
+    if (nextIndex === -1) {
+      // Reached the end of history navigation, restore original query
+      onChange(originalQueryBeforeNav);
+    } else {
+      const newValue = userMessages[userMessages.length - 1 - nextIndex];
+      onChange(newValue);
+    }
+    return true;
+  }, [
+    historyIndex,
+    setHistoryIndex,
+    originalQueryBeforeNav,
+    onChange,
+    userMessages,
+    isActive,
+  ]);
+
+  return {
+    handleSubmit,
+    navigateUp,
+    navigateDown,
+  };
+}

package/dist/ui/hooks/useKeypress.test.ts

@@ -0,0 +1,280 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import React from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { useKeypress, Key } from './useKeypress.js';
+import { KeypressProvider } from '../contexts/KeypressContext.js';
+import { useStdin } from 'ink';
+import { EventEmitter } from 'events';
+import { PassThrough } from 'stream';
+
+// Mock the 'ink' module to control stdin
+vi.mock('ink', async (importOriginal) => {
+  const original = await importOriginal<typeof import('ink')>();
+  return {
+    ...original,
+    useStdin: vi.fn(),
+  };
+});
+
+// Mock the 'readline' module
+vi.mock('readline', () => {
+  const mockedReadline = {
+    createInterface: vi.fn().mockReturnValue({ close: vi.fn() }),
+    // The paste workaround involves replacing stdin with a PassThrough stream.
+    // This mock ensures that when emitKeypressEvents is called on that
+    // stream, we simulate the 'keypress' events that the hook expects.
+    emitKeypressEvents: vi.fn((stream: EventEmitter) => {
+      if (stream instanceof PassThrough) {
+        stream.on('data', (data) => {
+          const str = data.toString();
+          for (const char of str) {
+            stream.emit('keypress', null, {
+              name: char,
+              sequence: char,
+              ctrl: false,
+              meta: false,
+              shift: false,
+            });
+          }
+        });
+      }
+    }),
+  };
+  return {
+    ...mockedReadline,
+    default: mockedReadline,
+  };
+});
+
+class MockStdin extends EventEmitter {
+  isTTY = true;
+  setRawMode = vi.fn();
+  on = this.addListener;
+  removeListener = this.removeListener;
+  write = vi.fn();
+  resume = vi.fn();
+
+  private isLegacy = false;
+
+  setLegacy(isLegacy: boolean) {
+    this.isLegacy = isLegacy;
+  }
+
+  // Helper to simulate a full paste event.
+  paste(text: string) {
+    if (this.isLegacy) {
+      const PASTE_START = '\x1B[200~';
+      const PASTE_END = '\x1B[201~';
+      this.emit('data', Buffer.from(`${PASTE_START}${text}${PASTE_END}`));
+    } else {
+      this.emit('keypress', null, { name: 'paste-start' });
+      this.emit('keypress', null, { sequence: text });
+      this.emit('keypress', null, { name: 'paste-end' });
+    }
+  }
+
+  // Helper to simulate the start of a paste, without the end.
+  startPaste(text: string) {
+    if (this.isLegacy) {
+      this.emit('data', Buffer.from('\x1B[200~' + text));
+    } else {
+      this.emit('keypress', null, { name: 'paste-start' });
+      this.emit('keypress', null, { sequence: text });
+    }
+  }
+
+  // Helper to simulate a single keypress event.
+  pressKey(key: Partial<Key>) {
+    if (this.isLegacy) {
+      this.emit('data', Buffer.from(key.sequence ?? ''));
+    } else {
+      this.emit('keypress', null, key);
+    }
+  }
+}
+
+describe('useKeypress', () => {
+  let stdin: MockStdin;
+  const mockSetRawMode = vi.fn();
+  const onKeypress = vi.fn();
+  let originalNodeVersion: string;
+
+  const wrapper = ({ children }: { children: React.ReactNode }) =>
+    React.createElement(KeypressProvider, null, children);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    stdin = new MockStdin();
+    (useStdin as vi.Mock).mockReturnValue({
+      stdin,
+      setRawMode: mockSetRawMode,
+    });
+
+    originalNodeVersion = process.versions.node;
+    vi.unstubAllEnvs();
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process.versions, 'node', {
+      value: originalNodeVersion,
+      configurable: true,
+    });
+  });
+
+  const setNodeVersion = (version: string) => {
+    Object.defineProperty(process.versions, 'node', {
+      value: version,
+      configurable: true,
+    });
+  };
+
+  it('should not listen if isActive is false', () => {
+    renderHook(() => useKeypress(onKeypress, { isActive: false }), {
+      wrapper,
+    });
+    act(() => stdin.pressKey({ name: 'a' }));
+    expect(onKeypress).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    { key: { name: 'a', sequence: 'a' } },
+    { key: { name: 'left', sequence: '\x1b[D' } },
+    { key: { name: 'right', sequence: '\x1b[C' } },
+    { key: { name: 'up', sequence: '\x1b[A' } },
+    { key: { name: 'down', sequence: '\x1b[B' } },
+  ])('should listen for keypress when active for key $key.name', ({ key }) => {
+    renderHook(() => useKeypress(onKeypress, { isActive: true }), { wrapper });
+    act(() => stdin.pressKey(key));
+    expect(onKeypress).toHaveBeenCalledWith(expect.objectContaining(key));
+  });
+
+  it('should set and release raw mode', () => {
+    const { unmount } = renderHook(
+      () => useKeypress(onKeypress, { isActive: true }),
+      { wrapper },
+    );
+    expect(mockSetRawMode).toHaveBeenCalledWith(true);
+    unmount();
+    expect(mockSetRawMode).toHaveBeenCalledWith(false);
+  });
+
+  it('should stop listening after being unmounted', () => {
+    const { unmount } = renderHook(
+      () => useKeypress(onKeypress, { isActive: true }),
+      { wrapper },
+    );
+    unmount();
+    act(() => stdin.pressKey({ name: 'a' }));
+    expect(onKeypress).not.toHaveBeenCalled();
+  });
+
+  it('should correctly identify alt+enter (meta key)', () => {
+    renderHook(() => useKeypress(onKeypress, { isActive: true }), { wrapper });
+    const key = { name: 'return', sequence: '\x1B\r' };
+    act(() => stdin.pressKey(key));
+    expect(onKeypress).toHaveBeenCalledWith(
+      expect.objectContaining({ ...key, meta: true, paste: false }),
+    );
+  });
+
+  describe.each([
+    {
+      description: 'Modern Node (>= v20)',
+      setup: () => setNodeVersion('20.0.0'),
+      isLegacy: false,
+    },
+    {
+      description: 'Legacy Node (< v20)',
+      setup: () => setNodeVersion('18.0.0'),
+      isLegacy: true,
+    },
+    {
+      description: 'Workaround Env Var',
+      setup: () => {
+        setNodeVersion('20.0.0');
+        vi.stubEnv('PASTE_WORKAROUND', 'true');
+      },
+      isLegacy: true,
+    },
+  ])('in $description', ({ setup, isLegacy }) => {
+    beforeEach(() => {
+      setup();
+      stdin.setLegacy(isLegacy);
+    });
+
+    it('should process a paste as a single event', () => {
+      renderHook(() => useKeypress(onKeypress, { isActive: true }), {
+        wrapper,
+      });
+      const pasteText = 'hello world';
+      act(() => stdin.paste(pasteText));
+
+      expect(onKeypress).toHaveBeenCalledTimes(1);
+      expect(onKeypress).toHaveBeenCalledWith({
+        name: '',
+        ctrl: false,
+        meta: false,
+        shift: false,
+        paste: true,
+        sequence: pasteText,
+      });
+    });
+
+    it('should handle keypress interspersed with pastes', () => {
+      renderHook(() => useKeypress(onKeypress, { isActive: true }), {
+        wrapper,
+      });
+
+      const keyA = { name: 'a', sequence: 'a' };
+      act(() => stdin.pressKey(keyA));
+      expect(onKeypress).toHaveBeenCalledWith(
+        expect.objectContaining({ ...keyA, paste: false }),
+      );
+
+      const pasteText = 'pasted';
+      act(() => stdin.paste(pasteText));
+      expect(onKeypress).toHaveBeenCalledWith(
+        expect.objectContaining({ paste: true, sequence: pasteText }),
+      );
+
+      const keyB = { name: 'b', sequence: 'b' };
+      act(() => stdin.pressKey(keyB));
+      expect(onKeypress).toHaveBeenCalledWith(
+        expect.objectContaining({ ...keyB, paste: false }),
+      );
+
+      expect(onKeypress).toHaveBeenCalledTimes(3);
+    });
+
+    it('should emit partial paste content if unmounted mid-paste', () => {
+      const { unmount } = renderHook(
+        () => useKeypress(onKeypress, { isActive: true }),
+        { wrapper },
+      );
+      const pasteText = 'incomplete paste';
+
+      act(() => stdin.startPaste(pasteText));
+
+      // No event should be fired yet.
+      expect(onKeypress).not.toHaveBeenCalled();
+
+      // Unmounting should trigger the flush.
+      unmount();
+
+      expect(onKeypress).toHaveBeenCalledTimes(1);
+      expect(onKeypress).toHaveBeenCalledWith({
+        name: '',
+        ctrl: false,
+        meta: false,
+        shift: false,
+        paste: true,
+        sequence: pasteText,
+      });
+    });
+  });
+});

package/dist/ui/hooks/useKeypress.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useEffect } from 'react';
+import {
+  useKeypressContext,
+  KeypressHandler,
+  Key,
+} from '../contexts/KeypressContext.js';
+
+export { Key };
+
+/**
+ * A hook that listens for keypress events from stdin.
+ *
+ * @param onKeypress - The callback function to execute on each keypress.
+ * @param options - Options to control the hook's behavior.
+ * @param options.isActive - Whether the hook should be actively listening for input.
+ */
+export function useKeypress(
+  onKeypress: KeypressHandler,
+  { isActive }: { isActive: boolean },
+) {
+  const { subscribe, unsubscribe } = useKeypressContext();
+
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+
+    subscribe(onKeypress);
+    return () => {
+      unsubscribe(onKeypress);
+    };
+  }, [isActive, onKeypress, subscribe, unsubscribe]);
+}