fss-link 1.0.49 → 1.0.51

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

@@ -1,261 +0,0 @@
-/**
- * @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

@@ -1,111 +0,0 @@
-/**
- * @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

@@ -1,280 +0,0 @@
-/**
- * @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

@@ -1,39 +0,0 @@
-/**
- * @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]);
-}