@xelauvas/xela-cli 0.1.0

package/src/components/design-system/FuzzyPicker.tsx

@@ -0,0 +1,312 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { useSearchInput } from '../../hooks/useSearchInput.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { clamp } from '../../ink/layout/geometry.js';
+import { Box, Text, useTerminalFocus } from '../../ink.js';
+import { SearchBox } from '../SearchBox.js';
+import { Byline } from './Byline.js';
+import { KeyboardShortcutHint } from './KeyboardShortcutHint.js';
+import { ListItem } from './ListItem.js';
+import { Pane } from './Pane.js';
+type PickerAction<T> = {
+  /** Hint label shown in the byline, e.g. "mention" → "Tab to mention". */
+  action: string;
+  handler: (item: T) => void;
+};
+type Props<T> = {
+  title: string;
+  placeholder?: string;
+  initialQuery?: string;
+  items: readonly T[];
+  getKey: (item: T) => string;
+  /** Keep to one line — preview handles overflow. */
+  renderItem: (item: T, isFocused: boolean) => React.ReactNode;
+  renderPreview?: (item: T) => React.ReactNode;
+  /** 'right' keeps hints stable (no bounce), but needs width. */
+  previewPosition?: 'bottom' | 'right';
+  visibleCount?: number;
+  /**
+   * 'up' puts items[0] at the bottom next to the input (atuin-style). Arrows
+   * always match screen direction — ↑ walks visually up regardless.
+   */
+  direction?: 'down' | 'up';
+  /** Caller owns filtering: re-filter on each call and pass new items. */
+  onQueryChange: (query: string) => void;
+  /** Enter key. Primary action. */
+  onSelect: (item: T) => void;
+  /**
+   * Tab key. If provided, Tab no longer aliases Enter — it gets its own
+   * handler and hint. Shift+Tab falls through to this if onShiftTab is unset.
+   */
+  onTab?: PickerAction<T>;
+  /** Shift+Tab key. Gets its own hint. */
+  onShiftTab?: PickerAction<T>;
+  /**
+   * Fires when the focused item changes (via arrows or when items reset).
+   * Useful for async preview loading — keeps I/O out of renderPreview.
+   */
+  onFocus?: (item: T | undefined) => void;
+  onCancel: () => void;
+  /** Shown when items is empty. Caller bakes loading/searching state into this. */
+  emptyMessage?: string | ((query: string) => string);
+  /**
+   * Status line below the list, e.g. "500+ matches" or "42 matches…".
+   * Caller decides when to show it — pass undefined to hide.
+   */
+  matchLabel?: string;
+  selectAction?: string;
+  extraHints?: React.ReactNode;
+};
+const DEFAULT_VISIBLE = 8;
+// Pane (paddingTop + Divider) + title + 3 gaps + SearchBox (rounded border = 3
+// rows) + hints. matchLabel adds +1 when present, accounted for separately.
+const CHROME_ROWS = 10;
+const MIN_VISIBLE = 2;
+export function FuzzyPicker<T>({
+  title,
+  placeholder = 'Type to search…',
+  initialQuery,
+  items,
+  getKey,
+  renderItem,
+  renderPreview,
+  previewPosition = 'bottom',
+  visibleCount: requestedVisible = DEFAULT_VISIBLE,
+  direction = 'down',
+  onQueryChange,
+  onSelect,
+  onTab,
+  onShiftTab,
+  onFocus,
+  onCancel,
+  emptyMessage = 'No results',
+  matchLabel,
+  selectAction = 'select',
+  extraHints
+}: Props<T>): React.ReactNode {
+  const isTerminalFocused = useTerminalFocus();
+  const {
+    rows,
+    columns
+  } = useTerminalSize();
+  const [focusedIndex, setFocusedIndex] = useState(0);
+
+  // Cap visibleCount so the picker never exceeds the terminal height. When it
+  // overflows, each re-render (arrow key, ctrl+p) mis-positions the cursor-up
+  // by the overflow amount and a previously-drawn line flashes blank.
+  const visibleCount = Math.max(MIN_VISIBLE, Math.min(requestedVisible, rows - CHROME_ROWS - (matchLabel ? 1 : 0)));
+
+  // Full hint row with onTab+onShiftTab is ~100 chars and wraps inconsistently
+  // below that. Compact mode drops shift+tab and shortens labels.
+  const compact = columns < 120;
+  const step = (delta: 1 | -1) => {
+    setFocusedIndex(i => clamp(i + delta, 0, items.length - 1));
+  };
+
+  // onKeyDown fires after useSearchInput's useInput, so onExit must be a
+  // no-op — return/downArrow are handled by handleKeyDown below. onCancel
+  // still covers escape/ctrl+c/ctrl+d. Backspace-on-empty is disabled so
+  // a held backspace doesn't eject the user from the dialog.
+  const {
+    query,
+    cursorOffset
+  } = useSearchInput({
+    isActive: true,
+    onExit: () => {},
+    onCancel,
+    initialQuery,
+    backspaceExitsOnEmpty: false
+  });
+  const handleKeyDown = (e: KeyboardEvent) => {
+    if (e.key === 'up' || e.ctrl && e.key === 'p') {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      step(direction === 'up' ? 1 : -1);
+      return;
+    }
+    if (e.key === 'down' || e.ctrl && e.key === 'n') {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      step(direction === 'up' ? -1 : 1);
+      return;
+    }
+    if (e.key === 'return') {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      const selected = items[focusedIndex];
+      if (selected) onSelect(selected);
+      return;
+    }
+    if (e.key === 'tab') {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      const selected = items[focusedIndex];
+      if (!selected) return;
+      const tabAction = e.shift ? onShiftTab ?? onTab : onTab;
+      if (tabAction) {
+        tabAction.handler(selected);
+      } else {
+        onSelect(selected);
+      }
+    }
+  };
+  useEffect(() => {
+    onQueryChange(query);
+    setFocusedIndex(0);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [query]);
+  useEffect(() => {
+    setFocusedIndex(i => clamp(i, 0, items.length - 1));
+  }, [items.length]);
+  const focused = items[focusedIndex];
+  useEffect(() => {
+    onFocus?.(focused);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [focused]);
+  const windowStart = clamp(focusedIndex - visibleCount + 1, 0, items.length - visibleCount);
+  const visible = items.slice(windowStart, windowStart + visibleCount);
+  const emptyText = typeof emptyMessage === 'function' ? emptyMessage(query) : emptyMessage;
+  const searchBox = <SearchBox query={query} cursorOffset={cursorOffset} placeholder={placeholder} isFocused isTerminalFocused={isTerminalFocused} />;
+  const listBlock = <List visible={visible} windowStart={windowStart} visibleCount={visibleCount} total={items.length} focusedIndex={focusedIndex} direction={direction} getKey={getKey} renderItem={renderItem} emptyText={emptyText} />;
+  const preview = renderPreview && focused ? <Box flexDirection="column" flexGrow={1}>
+        {renderPreview(focused)}
+      </Box> : null;
+
+  // Structure must not depend on preview truthiness — when focused goes
+  // undefined (e.g. delete clears matches), switching row→fragment would
+  // change both layout AND gap count, bouncing the searchBox below.
+  const listGroup = renderPreview && previewPosition === 'right' ? <Box flexDirection="row" gap={2} height={visibleCount + (matchLabel ? 1 : 0)}>
+        <Box flexDirection="column" flexShrink={0}>
+          {listBlock}
+          {matchLabel && <Text dimColor>{matchLabel}</Text>}
+        </Box>
+        {preview ?? <Box flexGrow={1} />}
+      </Box> :
+  // Box (not fragment) so the outer gap={1} doesn't insert a blank line
+  // between list/matchLabel/preview — that read as extra space above the
+  // prompt in direction='up'.
+  <Box flexDirection="column">
+        {listBlock}
+        {matchLabel && <Text dimColor>{matchLabel}</Text>}
+        {preview}
+      </Box>;
+  const inputAbove = direction !== 'up';
+  return <Pane color="permission">
+      <Box flexDirection="column" gap={1} tabIndex={0} autoFocus onKeyDown={handleKeyDown}>
+        <Text bold color="permission">
+          {title}
+        </Text>
+        {inputAbove && searchBox}
+        {listGroup}
+        {!inputAbove && searchBox}
+        <Text dimColor>
+          <Byline>
+            <KeyboardShortcutHint shortcut="↑/↓" action={compact ? 'nav' : 'navigate'} />
+            <KeyboardShortcutHint shortcut="Enter" action={compact ? firstWord(selectAction) : selectAction} />
+            {onTab && <KeyboardShortcutHint shortcut="Tab" action={onTab.action} />}
+            {onShiftTab && !compact && <KeyboardShortcutHint shortcut="shift+tab" action={onShiftTab.action} />}
+            <KeyboardShortcutHint shortcut="Esc" action="cancel" />
+            {extraHints}
+          </Byline>
+        </Text>
+      </Box>
+    </Pane>;
+}
+type ListProps<T> = Pick<Props<T>, 'visibleCount' | 'direction' | 'getKey' | 'renderItem'> & {
+  visible: readonly T[];
+  windowStart: number;
+  total: number;
+  focusedIndex: number;
+  emptyText: string;
+};
+function List(t0) {
+  const $ = _c(27);
+  const {
+    visible,
+    windowStart,
+    visibleCount,
+    total,
+    focusedIndex,
+    direction,
+    getKey,
+    renderItem,
+    emptyText
+  } = t0;
+  if (visible.length === 0) {
+    let t1;
+    if ($[0] !== emptyText) {
+      t1 = <Text dimColor={true}>{emptyText}</Text>;
+      $[0] = emptyText;
+      $[1] = t1;
+    } else {
+      t1 = $[1];
+    }
+    let t2;
+    if ($[2] !== t1 || $[3] !== visibleCount) {
+      t2 = <Box height={visibleCount} flexShrink={0}>{t1}</Box>;
+      $[2] = t1;
+      $[3] = visibleCount;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    return t2;
+  }
+  let t1;
+  if ($[5] !== direction || $[6] !== focusedIndex || $[7] !== getKey || $[8] !== renderItem || $[9] !== total || $[10] !== visible || $[11] !== visibleCount || $[12] !== windowStart) {
+    let t2;
+    if ($[14] !== direction || $[15] !== focusedIndex || $[16] !== getKey || $[17] !== renderItem || $[18] !== total || $[19] !== visible.length || $[20] !== visibleCount || $[21] !== windowStart) {
+      t2 = (item, i) => {
+        const actualIndex = windowStart + i;
+        const isFocused = actualIndex === focusedIndex;
+        const atLowEdge = i === 0 && windowStart > 0;
+        const atHighEdge = i === visible.length - 1 && windowStart + visibleCount < total;
+        return <ListItem key={getKey(item)} isFocused={isFocused} showScrollUp={direction === "up" ? atHighEdge : atLowEdge} showScrollDown={direction === "up" ? atLowEdge : atHighEdge} styled={false}>{renderItem(item, isFocused)}</ListItem>;
+      };
+      $[14] = direction;
+      $[15] = focusedIndex;
+      $[16] = getKey;
+      $[17] = renderItem;
+      $[18] = total;
+      $[19] = visible.length;
+      $[20] = visibleCount;
+      $[21] = windowStart;
+      $[22] = t2;
+    } else {
+      t2 = $[22];
+    }
+    t1 = visible.map(t2);
+    $[5] = direction;
+    $[6] = focusedIndex;
+    $[7] = getKey;
+    $[8] = renderItem;
+    $[9] = total;
+    $[10] = visible;
+    $[11] = visibleCount;
+    $[12] = windowStart;
+    $[13] = t1;
+  } else {
+    t1 = $[13];
+  }
+  const rows = t1;
+  const t2 = direction === "up" ? "column-reverse" : "column";
+  let t3;
+  if ($[23] !== rows || $[24] !== t2 || $[25] !== visibleCount) {
+    t3 = <Box height={visibleCount} flexShrink={0} flexDirection={t2}>{rows}</Box>;
+    $[23] = rows;
+    $[24] = t2;
+    $[25] = visibleCount;
+    $[26] = t3;
+  } else {
+    t3 = $[26];
+  }
+  return t3;
+}
+function firstWord(s: string): string {
+  const i = s.indexOf(' ');
+  return i === -1 ? s : s.slice(0, i);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","useSearchInput","useTerminalSize","KeyboardEvent","clamp","Box","Text","useTerminalFocus","SearchBox","Byline","KeyboardShortcutHint","ListItem","Pane","PickerAction","action","handler","item","T","Props","title","placeholder","initialQuery","items","getKey","renderItem","isFocused","ReactNode","renderPreview","previewPosition","visibleCount","direction","onQueryChange","query","onSelect","onTab","onShiftTab","onFocus","onCancel","emptyMessage","matchLabel","selectAction","extraHints","DEFAULT_VISIBLE","CHROME_ROWS","MIN_VISIBLE","FuzzyPicker","requestedVisible","isTerminalFocused","rows","columns","focusedIndex","setFocusedIndex","Math","max","min","compact","step","delta","i","length","cursorOffset","isActive","onExit","backspaceExitsOnEmpty","handleKeyDown","e","key","ctrl","preventDefault","stopImmediatePropagation","selected","tabAction","shift","focused","windowStart","visible","slice","emptyText","searchBox","listBlock","preview","listGroup","inputAbove","firstWord","ListProps","Pick","total","List","t0","$","_c","t1","t2","actualIndex","atLowEdge","atHighEdge","map","t3","s","indexOf"],"sources":["FuzzyPicker.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { useSearchInput } from '../../hooks/useSearchInput.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { clamp } from '../../ink/layout/geometry.js'\nimport { Box, Text, useTerminalFocus } from '../../ink.js'\nimport { SearchBox } from '../SearchBox.js'\nimport { Byline } from './Byline.js'\nimport { KeyboardShortcutHint } from './KeyboardShortcutHint.js'\nimport { ListItem } from './ListItem.js'\nimport { Pane } from './Pane.js'\n\ntype PickerAction<T> = {\n  /** Hint label shown in the byline, e.g. \"mention\" → \"Tab to mention\". */\n  action: string\n  handler: (item: T) => void\n}\n\ntype Props<T> = {\n  title: string\n  placeholder?: string\n  initialQuery?: string\n  items: readonly T[]\n  getKey: (item: T) => string\n  /** Keep to one line — preview handles overflow. */\n  renderItem: (item: T, isFocused: boolean) => React.ReactNode\n  renderPreview?: (item: T) => React.ReactNode\n  /** 'right' keeps hints stable (no bounce), but needs width. */\n  previewPosition?: 'bottom' | 'right'\n  visibleCount?: number\n  /**\n   * 'up' puts items[0] at the bottom next to the input (atuin-style). Arrows\n   * always match screen direction — ↑ walks visually up regardless.\n   */\n  direction?: 'down' | 'up'\n  /** Caller owns filtering: re-filter on each call and pass new items. */\n  onQueryChange: (query: string) => void\n  /** Enter key. Primary action. */\n  onSelect: (item: T) => void\n  /**\n   * Tab key. If provided, Tab no longer aliases Enter — it gets its own\n   * handler and hint. Shift+Tab falls through to this if onShiftTab is unset.\n   */\n  onTab?: PickerAction<T>\n  /** Shift+Tab key. Gets its own hint. */\n  onShiftTab?: PickerAction<T>\n  /**\n   * Fires when the focused item changes (via arrows or when items reset).\n   * Useful for async preview loading — keeps I/O out of renderPreview.\n   */\n  onFocus?: (item: T | undefined) => void\n  onCancel: () => void\n  /** Shown when items is empty. Caller bakes loading/searching state into this. */\n  emptyMessage?: string | ((query: string) => string)\n  /**\n   * Status line below the list, e.g. \"500+ matches\" or \"42 matches…\".\n   * Caller decides when to show it — pass undefined to hide.\n   */\n  matchLabel?: string\n  selectAction?: string\n  extraHints?: React.ReactNode\n}\n\nconst DEFAULT_VISIBLE = 8\n// Pane (paddingTop + Divider) + title + 3 gaps + SearchBox (rounded border = 3\n// rows) + hints. matchLabel adds +1 when present, accounted for separately.\nconst CHROME_ROWS = 10\nconst MIN_VISIBLE = 2\n\nexport function FuzzyPicker<T>({\n  title,\n  placeholder = 'Type to search…',\n  initialQuery,\n  items,\n  getKey,\n  renderItem,\n  renderPreview,\n  previewPosition = 'bottom',\n  visibleCount: requestedVisible = DEFAULT_VISIBLE,\n  direction = 'down',\n  onQueryChange,\n  onSelect,\n  onTab,\n  onShiftTab,\n  onFocus,\n  onCancel,\n  emptyMessage = 'No results',\n  matchLabel,\n  selectAction = 'select',\n  extraHints,\n}: Props<T>): React.ReactNode {\n  const isTerminalFocused = useTerminalFocus()\n  const { rows, columns } = useTerminalSize()\n  const [focusedIndex, setFocusedIndex] = useState(0)\n\n  // Cap visibleCount so the picker never exceeds the terminal height. When it\n  // overflows, each re-render (arrow key, ctrl+p) mis-positions the cursor-up\n  // by the overflow amount and a previously-drawn line flashes blank.\n  const visibleCount = Math.max(\n    MIN_VISIBLE,\n    Math.min(requestedVisible, rows - CHROME_ROWS - (matchLabel ? 1 : 0)),\n  )\n\n  // Full hint row with onTab+onShiftTab is ~100 chars and wraps inconsistently\n  // below that. Compact mode drops shift+tab and shortens labels.\n  const compact = columns < 120\n\n  const step = (delta: 1 | -1) => {\n    setFocusedIndex(i => clamp(i + delta, 0, items.length - 1))\n  }\n\n  // onKeyDown fires after useSearchInput's useInput, so onExit must be a\n  // no-op — return/downArrow are handled by handleKeyDown below. onCancel\n  // still covers escape/ctrl+c/ctrl+d. Backspace-on-empty is disabled so\n  // a held backspace doesn't eject the user from the dialog.\n  const { query, cursorOffset } = useSearchInput({\n    isActive: true,\n    onExit: () => {},\n    onCancel,\n    initialQuery,\n    backspaceExitsOnEmpty: false,\n  })\n\n  const handleKeyDown = (e: KeyboardEvent) => {\n    if (e.key === 'up' || (e.ctrl && e.key === 'p')) {\n      e.preventDefault()\n      e.stopImmediatePropagation()\n      step(direction === 'up' ? 1 : -1)\n      return\n    }\n    if (e.key === 'down' || (e.ctrl && e.key === 'n')) {\n      e.preventDefault()\n      e.stopImmediatePropagation()\n      step(direction === 'up' ? -1 : 1)\n      return\n    }\n    if (e.key === 'return') {\n      e.preventDefault()\n      e.stopImmediatePropagation()\n      const selected = items[focusedIndex]\n      if (selected) onSelect(selected)\n      return\n    }\n    if (e.key === 'tab') {\n      e.preventDefault()\n      e.stopImmediatePropagation()\n      const selected = items[focusedIndex]\n      if (!selected) return\n      const tabAction = e.shift ? (onShiftTab ?? onTab) : onTab\n      if (tabAction) {\n        tabAction.handler(selected)\n      } else {\n        onSelect(selected)\n      }\n    }\n  }\n\n  useEffect(() => {\n    onQueryChange(query)\n    setFocusedIndex(0)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [query])\n\n  useEffect(() => {\n    setFocusedIndex(i => clamp(i, 0, items.length - 1))\n  }, [items.length])\n\n  const focused = items[focusedIndex]\n  useEffect(() => {\n    onFocus?.(focused)\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [focused])\n\n  const windowStart = clamp(\n    focusedIndex - visibleCount + 1,\n    0,\n    items.length - visibleCount,\n  )\n  const visible = items.slice(windowStart, windowStart + visibleCount)\n\n  const emptyText =\n    typeof emptyMessage === 'function' ? emptyMessage(query) : emptyMessage\n\n  const searchBox = (\n    <SearchBox\n      query={query}\n      cursorOffset={cursorOffset}\n      placeholder={placeholder}\n      isFocused\n      isTerminalFocused={isTerminalFocused}\n    />\n  )\n\n  const listBlock = (\n    <List\n      visible={visible}\n      windowStart={windowStart}\n      visibleCount={visibleCount}\n      total={items.length}\n      focusedIndex={focusedIndex}\n      direction={direction}\n      getKey={getKey}\n      renderItem={renderItem}\n      emptyText={emptyText}\n    />\n  )\n\n  const preview =\n    renderPreview && focused ? (\n      <Box flexDirection=\"column\" flexGrow={1}>\n        {renderPreview(focused)}\n      </Box>\n    ) : null\n\n  // Structure must not depend on preview truthiness — when focused goes\n  // undefined (e.g. delete clears matches), switching row→fragment would\n  // change both layout AND gap count, bouncing the searchBox below.\n  const listGroup =\n    renderPreview && previewPosition === 'right' ? (\n      <Box\n        flexDirection=\"row\"\n        gap={2}\n        height={visibleCount + (matchLabel ? 1 : 0)}\n      >\n        <Box flexDirection=\"column\" flexShrink={0}>\n          {listBlock}\n          {matchLabel && <Text dimColor>{matchLabel}</Text>}\n        </Box>\n        {preview ?? <Box flexGrow={1} />}\n      </Box>\n    ) : (\n      // Box (not fragment) so the outer gap={1} doesn't insert a blank line\n      // between list/matchLabel/preview — that read as extra space above the\n      // prompt in direction='up'.\n      <Box flexDirection=\"column\">\n        {listBlock}\n        {matchLabel && <Text dimColor>{matchLabel}</Text>}\n        {preview}\n      </Box>\n    )\n\n  const inputAbove = direction !== 'up'\n  return (\n    <Pane color=\"permission\">\n      <Box\n        flexDirection=\"column\"\n        gap={1}\n        tabIndex={0}\n        autoFocus\n        onKeyDown={handleKeyDown}\n      >\n        <Text bold color=\"permission\">\n          {title}\n        </Text>\n        {inputAbove && searchBox}\n        {listGroup}\n        {!inputAbove && searchBox}\n        <Text dimColor>\n          <Byline>\n            <KeyboardShortcutHint\n              shortcut=\"↑/↓\"\n              action={compact ? 'nav' : 'navigate'}\n            />\n            <KeyboardShortcutHint\n              shortcut=\"Enter\"\n              action={compact ? firstWord(selectAction) : selectAction}\n            />\n            {onTab && (\n              <KeyboardShortcutHint shortcut=\"Tab\" action={onTab.action} />\n            )}\n            {onShiftTab && !compact && (\n              <KeyboardShortcutHint\n                shortcut=\"shift+tab\"\n                action={onShiftTab.action}\n              />\n            )}\n            <KeyboardShortcutHint shortcut=\"Esc\" action=\"cancel\" />\n            {extraHints}\n          </Byline>\n        </Text>\n      </Box>\n    </Pane>\n  )\n}\n\ntype ListProps<T> = Pick<\n  Props<T>,\n  'visibleCount' | 'direction' | 'getKey' | 'renderItem'\n> & {\n  visible: readonly T[]\n  windowStart: number\n  total: number\n  focusedIndex: number\n  emptyText: string\n}\n\nfunction List<T>({\n  visible,\n  windowStart,\n  visibleCount,\n  total,\n  focusedIndex,\n  direction,\n  getKey,\n  renderItem,\n  emptyText,\n}: ListProps<T>): React.ReactNode {\n  if (visible.length === 0) {\n    return (\n      <Box height={visibleCount} flexShrink={0}>\n        <Text dimColor>{emptyText}</Text>\n      </Box>\n    )\n  }\n\n  const rows = visible.map((item, i) => {\n    const actualIndex = windowStart + i\n    const isFocused = actualIndex === focusedIndex\n    const atLowEdge = i === 0 && windowStart > 0\n    const atHighEdge =\n      i === visible.length - 1 && windowStart + visibleCount! < total\n    return (\n      <ListItem\n        key={getKey(item)}\n        isFocused={isFocused}\n        showScrollUp={direction === 'up' ? atHighEdge : atLowEdge}\n        showScrollDown={direction === 'up' ? atLowEdge : atHighEdge}\n        styled={false}\n      >\n        {renderItem(item, isFocused)}\n      </ListItem>\n    )\n  })\n\n  return (\n    <Box\n      height={visibleCount}\n      flexShrink={0}\n      flexDirection={direction === 'up' ? 'column-reverse' : 'column'}\n    >\n      {rows}\n    </Box>\n  )\n}\n\nfunction firstWord(s: string): string {\n  const i = s.indexOf(' ')\n  return i === -1 ? s : s.slice(0, i)\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/design-system/KeyboardShortcutHint.tsx

@@ -0,0 +1,81 @@
+import { c as _c } from "react/compiler-runtime";
+import React from 'react';
+import Text from '../../ink/components/Text.js';
+type Props = {
+  /** The key or chord to display (e.g., "ctrl+o", "Enter", "↑/↓") */
+  shortcut: string;
+  /** The action the key performs (e.g., "expand", "select", "navigate") */
+  action: string;
+  /** Whether to wrap the hint in parentheses. Default: false */
+  parens?: boolean;
+  /** Whether to render the shortcut in bold. Default: false */
+  bold?: boolean;
+};
+
+/**
+ * Renders a keyboard shortcut hint like "ctrl+o to expand" or "(tab to toggle)"
+ *
+ * Wrap in <Text dimColor> for the common dim styling.
+ *
+ * @example
+ * // Simple hint wrapped in dim Text
+ * <Text dimColor><KeyboardShortcutHint shortcut="esc" action="cancel" /></Text>
+ *
+ * // With parentheses: "(ctrl+o to expand)"
+ * <Text dimColor><KeyboardShortcutHint shortcut="ctrl+o" action="expand" parens /></Text>
+ *
+ * // With bold shortcut: "Enter to confirm" (Enter is bold)
+ * <Text dimColor><KeyboardShortcutHint shortcut="Enter" action="confirm" bold /></Text>
+ *
+ * // Multiple hints with middot separator - use Byline
+ * <Text dimColor>
+ *   <Byline>
+ *     <KeyboardShortcutHint shortcut="Enter" action="confirm" />
+ *     <KeyboardShortcutHint shortcut="Esc" action="cancel" />
+ *   </Byline>
+ * </Text>
+ */
+export function KeyboardShortcutHint(t0) {
+  const $ = _c(9);
+  const {
+    shortcut,
+    action,
+    parens: t1,
+    bold: t2
+  } = t0;
+  const parens = t1 === undefined ? false : t1;
+  const bold = t2 === undefined ? false : t2;
+  let t3;
+  if ($[0] !== bold || $[1] !== shortcut) {
+    t3 = bold ? <Text bold={true}>{shortcut}</Text> : shortcut;
+    $[0] = bold;
+    $[1] = shortcut;
+    $[2] = t3;
+  } else {
+    t3 = $[2];
+  }
+  const shortcutText = t3;
+  if (parens) {
+    let t4;
+    if ($[3] !== action || $[4] !== shortcutText) {
+      t4 = <Text>({shortcutText} to {action})</Text>;
+      $[3] = action;
+      $[4] = shortcutText;
+      $[5] = t4;
+    } else {
+      t4 = $[5];
+    }
+    return t4;
+  }
+  let t4;
+  if ($[6] !== action || $[7] !== shortcutText) {
+    t4 = <Text>{shortcutText} to {action}</Text>;
+    $[6] = action;
+    $[7] = shortcutText;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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