@xelauvas/xela-cli 0.1.0

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

@@ -0,0 +1,95 @@
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import React from 'react';
+import { Text } from '../../ink.js';
+type Status = 'success' | 'error' | 'warning' | 'info' | 'pending' | 'loading';
+type Props = {
+  /**
+   * The status to display. Determines both the icon and color.
+   *
+   * - `success`: Green checkmark (✓)
+   * - `error`: Red cross (✗)
+   * - `warning`: Yellow warning symbol (⚠)
+   * - `info`: Blue info symbol (ℹ)
+   * - `pending`: Dimmed circle (○)
+   * - `loading`: Dimmed ellipsis (…)
+   */
+  status: Status;
+  /**
+   * Include a trailing space after the icon. Useful when followed by text.
+   * @default false
+   */
+  withSpace?: boolean;
+};
+const STATUS_CONFIG: Record<Status, {
+  icon: string;
+  color: 'success' | 'error' | 'warning' | 'suggestion' | undefined;
+}> = {
+  success: {
+    icon: figures.tick,
+    color: 'success'
+  },
+  error: {
+    icon: figures.cross,
+    color: 'error'
+  },
+  warning: {
+    icon: figures.warning,
+    color: 'warning'
+  },
+  info: {
+    icon: figures.info,
+    color: 'suggestion'
+  },
+  pending: {
+    icon: figures.circle,
+    color: undefined
+  },
+  loading: {
+    icon: '…',
+    color: undefined
+  }
+};
+
+/**
+ * Renders a status indicator icon with appropriate color.
+ *
+ * @example
+ * // Success indicator
+ * <StatusIcon status="success" />
+ *
+ * @example
+ * // Error with trailing space for text
+ * <Text><StatusIcon status="error" withSpace />Failed to connect</Text>
+ *
+ * @example
+ * // Status line pattern
+ * <Text>
+ *   <StatusIcon status="pending" withSpace />
+ *   Waiting for response
+ * </Text>
+ */
+export function StatusIcon(t0) {
+  const $ = _c(5);
+  const {
+    status,
+    withSpace: t1
+  } = t0;
+  const withSpace = t1 === undefined ? false : t1;
+  const config = STATUS_CONFIG[status];
+  const t2 = !config.color;
+  const t3 = withSpace && " ";
+  let t4;
+  if ($[0] !== config.color || $[1] !== config.icon || $[2] !== t2 || $[3] !== t3) {
+    t4 = <Text color={config.color} dimColor={t2}>{config.icon}{t3}</Text>;
+    $[0] = config.color;
+    $[1] = config.icon;
+    $[2] = t2;
+    $[3] = t3;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,340 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useCallback, useContext, useEffect, useState } from 'react';
+import { useIsInsideModal, useModalScrollRef } from '../../context/modalContext.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import ScrollBox from '../../ink/components/ScrollBox.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { Box, Text } from '../../ink.js';
+import { useKeybindings } from '../../keybindings/useKeybinding.js';
+import type { Theme } from '../../utils/theme.js';
+type TabsProps = {
+  children: Array<React.ReactElement<TabProps>>;
+  title?: string;
+  color?: keyof Theme;
+  defaultTab?: string;
+  hidden?: boolean;
+  useFullWidth?: boolean;
+  /** Controlled mode: current selected tab id/title */
+  selectedTab?: string;
+  /** Controlled mode: callback when tab changes */
+  onTabChange?: (tabId: string) => void;
+  /** Optional banner to display below tabs header */
+  banner?: React.ReactNode;
+  /** Disable keyboard navigation (e.g. when a child component handles arrow keys) */
+  disableNavigation?: boolean;
+  /**
+   * Initial focus state for the tab header row. Defaults to true (header
+   * focused, nav always works). Keep the default for Select/list content —
+   * those only use up/down so there's no conflict; pass
+   * isDisabled={headerFocused} to the Select instead. Only set false when
+   * content actually binds left/right/tab (e.g. enum cycling), and show a
+   * "↑ tabs" footer hint — without it tabs look broken.
+   */
+  initialHeaderFocused?: boolean;
+  /**
+   * Fixed height for the content area. When set, all tabs render within the
+   * same height (overflow hidden) so switching tabs doesn't cause layout
+   * shifts. Shorter tabs get whitespace; taller tabs are clipped.
+   */
+  contentHeight?: number;
+  /**
+   * Let Tab/←/→ switch tabs from focused content. Opt-in since some
+   * content uses those keys; pass a reactive boolean to cede them when
+   * needed. Switching from content focuses the header.
+   */
+  navFromContent?: boolean;
+};
+type TabsContextValue = {
+  selectedTab: string | undefined;
+  width: number | undefined;
+  headerFocused: boolean;
+  focusHeader: () => void;
+  blurHeader: () => void;
+  registerOptIn: () => () => void;
+};
+const TabsContext = createContext<TabsContextValue>({
+  selectedTab: undefined,
+  width: undefined,
+  // Default for components rendered outside a Tabs (tests, standalone):
+  // content has focus, focusHeader is a no-op.
+  headerFocused: false,
+  focusHeader: () => {},
+  blurHeader: () => {},
+  registerOptIn: () => () => {}
+});
+export function Tabs(t0) {
+  const $ = _c(25);
+  const {
+    title,
+    color,
+    defaultTab,
+    children,
+    hidden,
+    useFullWidth,
+    selectedTab: controlledSelectedTab,
+    onTabChange,
+    banner,
+    disableNavigation,
+    initialHeaderFocused: t1,
+    contentHeight,
+    navFromContent: t2
+  } = t0;
+  const initialHeaderFocused = t1 === undefined ? true : t1;
+  const navFromContent = t2 === undefined ? false : t2;
+  const {
+    columns: terminalWidth
+  } = useTerminalSize();
+  const tabs = children.map(_temp);
+  const defaultTabIndex = defaultTab ? tabs.findIndex(tab => defaultTab === tab[0]) : 0;
+  const isControlled = controlledSelectedTab !== undefined;
+  const [internalSelectedTab, setInternalSelectedTab] = useState(defaultTabIndex !== -1 ? defaultTabIndex : 0);
+  const controlledTabIndex = isControlled ? tabs.findIndex(tab_0 => tab_0[0] === controlledSelectedTab) : -1;
+  const selectedTabIndex = isControlled ? controlledTabIndex !== -1 ? controlledTabIndex : 0 : internalSelectedTab;
+  const modalScrollRef = useModalScrollRef();
+  const [headerFocused, setHeaderFocused] = useState(initialHeaderFocused);
+  let t3;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = () => setHeaderFocused(true);
+    $[0] = t3;
+  } else {
+    t3 = $[0];
+  }
+  const focusHeader = t3;
+  let t4;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = () => setHeaderFocused(false);
+    $[1] = t4;
+  } else {
+    t4 = $[1];
+  }
+  const blurHeader = t4;
+  const [optInCount, setOptInCount] = useState(0);
+  let t5;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = () => {
+      setOptInCount(_temp2);
+      return () => setOptInCount(_temp3);
+    };
+    $[2] = t5;
+  } else {
+    t5 = $[2];
+  }
+  const registerOptIn = t5;
+  const optedIn = optInCount > 0;
+  const handleTabChange = offset => {
+    const newIndex = (selectedTabIndex + tabs.length + offset) % tabs.length;
+    const newTabId = tabs[newIndex]?.[0];
+    if (isControlled && onTabChange && newTabId) {
+      onTabChange(newTabId);
+    } else {
+      setInternalSelectedTab(newIndex);
+    }
+    setHeaderFocused(true);
+  };
+  const t6 = !hidden && !disableNavigation && headerFocused;
+  let t7;
+  if ($[3] !== t6) {
+    t7 = {
+      context: "Tabs",
+      isActive: t6
+    };
+    $[3] = t6;
+    $[4] = t7;
+  } else {
+    t7 = $[4];
+  }
+  useKeybindings({
+    "tabs:next": () => handleTabChange(1),
+    "tabs:previous": () => handleTabChange(-1)
+  }, t7);
+  let t8;
+  if ($[5] !== headerFocused || $[6] !== hidden || $[7] !== optedIn) {
+    t8 = e => {
+      if (!headerFocused || !optedIn || hidden) {
+        return;
+      }
+      if (e.key === "down") {
+        e.preventDefault();
+        setHeaderFocused(false);
+      }
+    };
+    $[5] = headerFocused;
+    $[6] = hidden;
+    $[7] = optedIn;
+    $[8] = t8;
+  } else {
+    t8 = $[8];
+  }
+  const handleKeyDown = t8;
+  const t9 = navFromContent && !headerFocused && optedIn && !hidden && !disableNavigation;
+  let t10;
+  if ($[9] !== t9) {
+    t10 = {
+      context: "Tabs",
+      isActive: t9
+    };
+    $[9] = t9;
+    $[10] = t10;
+  } else {
+    t10 = $[10];
+  }
+  useKeybindings({
+    "tabs:next": () => {
+      handleTabChange(1);
+      setHeaderFocused(true);
+    },
+    "tabs:previous": () => {
+      handleTabChange(-1);
+      setHeaderFocused(true);
+    }
+  }, t10);
+  const titleWidth = title ? stringWidth(title) + 1 : 0;
+  const tabsWidth = tabs.reduce(_temp4, 0);
+  const usedWidth = titleWidth + tabsWidth;
+  const spacerWidth = useFullWidth ? Math.max(0, terminalWidth - usedWidth) : 0;
+  const contentWidth = useFullWidth ? terminalWidth : undefined;
+  const T0 = Box;
+  const t11 = "column";
+  const t12 = 0;
+  const t13 = true;
+  const t14 = modalScrollRef ? 0 : undefined;
+  const t15 = !hidden && <Box flexDirection="row" gap={1} flexShrink={modalScrollRef ? 0 : undefined}>{title !== undefined && <Text bold={true} color={color}>{title}</Text>}{tabs.map((t16, i) => {
+      const [id, title_0] = t16;
+      const isCurrent = selectedTabIndex === i;
+      const hasColorCursor = color && isCurrent && headerFocused;
+      return <Text key={id} backgroundColor={hasColorCursor ? color : undefined} color={hasColorCursor ? "inverseText" : undefined} inverse={isCurrent && !hasColorCursor} bold={isCurrent}>{" "}{title_0}{" "}</Text>;
+    })}{spacerWidth > 0 && <Text>{" ".repeat(spacerWidth)}</Text>}</Box>;
+  let t17;
+  if ($[11] !== children || $[12] !== contentHeight || $[13] !== contentWidth || $[14] !== hidden || $[15] !== modalScrollRef || $[16] !== selectedTabIndex) {
+    t17 = modalScrollRef ? <Box width={contentWidth} marginTop={hidden ? 0 : 1} flexShrink={0}><ScrollBox key={selectedTabIndex} ref={modalScrollRef} flexDirection="column" flexShrink={0}>{children}</ScrollBox></Box> : <Box width={contentWidth} marginTop={hidden ? 0 : 1} height={contentHeight} overflowY={contentHeight !== undefined ? "hidden" : undefined}>{children}</Box>;
+    $[11] = children;
+    $[12] = contentHeight;
+    $[13] = contentWidth;
+    $[14] = hidden;
+    $[15] = modalScrollRef;
+    $[16] = selectedTabIndex;
+    $[17] = t17;
+  } else {
+    t17 = $[17];
+  }
+  let t18;
+  if ($[18] !== T0 || $[19] !== banner || $[20] !== handleKeyDown || $[21] !== t14 || $[22] !== t15 || $[23] !== t17) {
+    t18 = <T0 flexDirection={t11} tabIndex={t12} autoFocus={t13} onKeyDown={handleKeyDown} flexShrink={t14}>{t15}{banner}{t17}</T0>;
+    $[18] = T0;
+    $[19] = banner;
+    $[20] = handleKeyDown;
+    $[21] = t14;
+    $[22] = t15;
+    $[23] = t17;
+    $[24] = t18;
+  } else {
+    t18 = $[24];
+  }
+  return <TabsContext.Provider value={{
+    selectedTab: tabs[selectedTabIndex][0],
+    width: contentWidth,
+    headerFocused,
+    focusHeader,
+    blurHeader,
+    registerOptIn
+  }}>{t18}</TabsContext.Provider>;
+}
+function _temp4(sum, t0) {
+  const [, tabTitle] = t0;
+  return sum + (tabTitle ? stringWidth(tabTitle) : 0) + 2 + 1;
+}
+function _temp3(n_0) {
+  return n_0 - 1;
+}
+function _temp2(n) {
+  return n + 1;
+}
+function _temp(child) {
+  return [child.props.id ?? child.props.title, child.props.title];
+}
+type TabProps = {
+  title: string;
+  id?: string;
+  children: React.ReactNode;
+};
+export function Tab(t0) {
+  const $ = _c(4);
+  const {
+    title,
+    id,
+    children
+  } = t0;
+  const {
+    selectedTab,
+    width
+  } = useContext(TabsContext);
+  const insideModal = useIsInsideModal();
+  if (selectedTab !== (id ?? title)) {
+    return null;
+  }
+  const t1 = insideModal ? 0 : undefined;
+  let t2;
+  if ($[0] !== children || $[1] !== t1 || $[2] !== width) {
+    t2 = <Box width={width} flexShrink={t1}>{children}</Box>;
+    $[0] = children;
+    $[1] = t1;
+    $[2] = width;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  return t2;
+}
+export function useTabsWidth() {
+  const {
+    width
+  } = useContext(TabsContext);
+  return width;
+}
+
+/**
+ * Opt into header-focus gating. Returns the current header focus state and a
+ * callback to hand focus back to the tab row. For a Select, pass
+ * `isDisabled={headerFocused}` and `onUpFromFirstItem={focusHeader}`; keep the
+ * parent Tabs' initialHeaderFocused at its default so tab/←/→ work on mount.
+ *
+ * Calling this hook registers a ↓-blurs-header opt-in on mount. Don't call it
+ * above an early return that renders static text — ↓ will blur the header with
+ * no onUpFromFirstItem to recover. Split the component so the hook only runs
+ * when the Select renders.
+ */
+export function useTabHeaderFocus() {
+  const $ = _c(6);
+  const {
+    headerFocused,
+    focusHeader,
+    blurHeader,
+    registerOptIn
+  } = useContext(TabsContext);
+  let t0;
+  if ($[0] !== registerOptIn) {
+    t0 = [registerOptIn];
+    $[0] = registerOptIn;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  useEffect(registerOptIn, t0);
+  let t1;
+  if ($[2] !== blurHeader || $[3] !== focusHeader || $[4] !== headerFocused) {
+    t1 = {
+      headerFocused,
+      focusHeader,
+      blurHeader
+    };
+    $[2] = blurHeader;
+    $[3] = focusHeader;
+    $[4] = headerFocused;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  return t1;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","useCallback","useContext","useEffect","useState","useIsInsideModal","useModalScrollRef","useTerminalSize","ScrollBox","KeyboardEvent","stringWidth","Box","Text","useKeybindings","Theme","TabsProps","children","Array","ReactElement","TabProps","title","color","defaultTab","hidden","useFullWidth","selectedTab","onTabChange","tabId","banner","ReactNode","disableNavigation","initialHeaderFocused","contentHeight","navFromContent","TabsContextValue","width","headerFocused","focusHeader","blurHeader","registerOptIn","TabsContext","undefined","Tabs","t0","$","_c","controlledSelectedTab","t1","t2","columns","terminalWidth","tabs","map","_temp","defaultTabIndex","findIndex","tab","isControlled","internalSelectedTab","setInternalSelectedTab","controlledTabIndex","tab_0","selectedTabIndex","modalScrollRef","setHeaderFocused","t3","Symbol","for","t4","optInCount","setOptInCount","t5","_temp2","_temp3","optedIn","handleTabChange","offset","newIndex","length","newTabId","t6","t7","context","isActive","tabs:next","tabs:previous","t8","e","key","preventDefault","handleKeyDown","t9","t10","titleWidth","tabsWidth","reduce","_temp4","usedWidth","spacerWidth","Math","max","contentWidth","T0","t11","t12","t13","t14","t15","t16","i","id","title_0","isCurrent","hasColorCursor","repeat","t17","t18","sum","tabTitle","n_0","n","child","props","Tab","insideModal","useTabsWidth","useTabHeaderFocus"],"sources":["Tabs.tsx"],"sourcesContent":["import React, {\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useState,\n} from 'react'\nimport {\n  useIsInsideModal,\n  useModalScrollRef,\n} from '../../context/modalContext.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport ScrollBox from '../../ink/components/ScrollBox.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { Box, Text } from '../../ink.js'\nimport { useKeybindings } from '../../keybindings/useKeybinding.js'\nimport type { Theme } from '../../utils/theme.js'\n\ntype TabsProps = {\n  children: Array<React.ReactElement<TabProps>>\n  title?: string\n  color?: keyof Theme\n  defaultTab?: string\n  hidden?: boolean\n  useFullWidth?: boolean\n  /** Controlled mode: current selected tab id/title */\n  selectedTab?: string\n  /** Controlled mode: callback when tab changes */\n  onTabChange?: (tabId: string) => void\n  /** Optional banner to display below tabs header */\n  banner?: React.ReactNode\n  /** Disable keyboard navigation (e.g. when a child component handles arrow keys) */\n  disableNavigation?: boolean\n  /**\n   * Initial focus state for the tab header row. Defaults to true (header\n   * focused, nav always works). Keep the default for Select/list content —\n   * those only use up/down so there's no conflict; pass\n   * isDisabled={headerFocused} to the Select instead. Only set false when\n   * content actually binds left/right/tab (e.g. enum cycling), and show a\n   * \"↑ tabs\" footer hint — without it tabs look broken.\n   */\n  initialHeaderFocused?: boolean\n  /**\n   * Fixed height for the content area. When set, all tabs render within the\n   * same height (overflow hidden) so switching tabs doesn't cause layout\n   * shifts. Shorter tabs get whitespace; taller tabs are clipped.\n   */\n  contentHeight?: number\n  /**\n   * Let Tab/←/→ switch tabs from focused content. Opt-in since some\n   * content uses those keys; pass a reactive boolean to cede them when\n   * needed. Switching from content focuses the header.\n   */\n  navFromContent?: boolean\n}\n\ntype TabsContextValue = {\n  selectedTab: string | undefined\n  width: number | undefined\n  headerFocused: boolean\n  focusHeader: () => void\n  blurHeader: () => void\n  registerOptIn: () => () => void\n}\n\nconst TabsContext = createContext<TabsContextValue>({\n  selectedTab: undefined,\n  width: undefined,\n  // Default for components rendered outside a Tabs (tests, standalone):\n  // content has focus, focusHeader is a no-op.\n  headerFocused: false,\n  focusHeader: () => {},\n  blurHeader: () => {},\n  registerOptIn: () => () => {},\n})\n\nexport function Tabs({\n  title,\n  color,\n  defaultTab,\n  children,\n  hidden,\n  useFullWidth,\n  selectedTab: controlledSelectedTab,\n  onTabChange,\n  banner,\n  disableNavigation,\n  initialHeaderFocused = true,\n  contentHeight,\n  navFromContent = false,\n}: TabsProps): React.ReactNode {\n  const { columns: terminalWidth } = useTerminalSize()\n  const tabs = children.map(child => [\n    child.props.id ?? child.props.title,\n    child.props.title,\n  ])\n  const defaultTabIndex = defaultTab\n    ? tabs.findIndex(tab => defaultTab === tab[0])\n    : 0\n\n  // Support both controlled and uncontrolled modes\n  const isControlled = controlledSelectedTab !== undefined\n  const [internalSelectedTab, setInternalSelectedTab] = useState(\n    defaultTabIndex !== -1 ? defaultTabIndex : 0,\n  )\n\n  // In controlled mode, find the index of the controlled tab\n  const controlledTabIndex = isControlled\n    ? tabs.findIndex(tab => tab[0] === controlledSelectedTab)\n    : -1\n  const selectedTabIndex = isControlled\n    ? controlledTabIndex !== -1\n      ? controlledTabIndex\n      : 0\n    : internalSelectedTab\n\n  const modalScrollRef = useModalScrollRef()\n\n  // Header focus: left/right/tab only switch tabs when the header row is\n  // focused. Children with interactive content call focusHeader() (via\n  // useTabHeaderFocus) on up-arrow to hand focus back here; down-arrow\n  // returns it. Tabs that never call the hook see no behavior change —\n  // initialHeaderFocused defaults to true so nav always works.\n  const [headerFocused, setHeaderFocused] = useState(initialHeaderFocused)\n  const focusHeader = useCallback(() => setHeaderFocused(true), [])\n  const blurHeader = useCallback(() => setHeaderFocused(false), [])\n  // Count of mounted children using useTabHeaderFocus(). Down-arrow blur and\n  // the ↓ hint only engage when at least one child has opted in — otherwise\n  // pressing down on a legacy tab would strand the user with nav disabled.\n  const [optInCount, setOptInCount] = useState(0)\n  const registerOptIn = useCallback(() => {\n    setOptInCount(n => n + 1)\n    return () => setOptInCount(n => n - 1)\n  }, [])\n  const optedIn = optInCount > 0\n\n  const handleTabChange = (offset: number) => {\n    const newIndex = (selectedTabIndex + tabs.length + offset) % tabs.length\n    const newTabId = tabs[newIndex]?.[0]\n\n    if (isControlled && onTabChange && newTabId) {\n      onTabChange(newTabId)\n    } else {\n      setInternalSelectedTab(newIndex)\n    }\n    // Tab switching is a header action — stay focused so the user can keep\n    // cycling. The newly mounted tab can blur via its own interaction.\n    setHeaderFocused(true)\n  }\n\n  useKeybindings(\n    {\n      'tabs:next': () => handleTabChange(1),\n      'tabs:previous': () => handleTabChange(-1),\n    },\n    {\n      context: 'Tabs',\n      isActive: !hidden && !disableNavigation && headerFocused,\n    },\n  )\n\n  // When the header is focused, down-arrow returns focus to content. Only\n  // active when the selected tab has opted in via useTabHeaderFocus() —\n  // legacy tabs have nowhere to return focus to.\n  const handleKeyDown = (e: KeyboardEvent) => {\n    if (!headerFocused || !optedIn || hidden) return\n    if (e.key === 'down') {\n      e.preventDefault()\n      setHeaderFocused(false)\n    }\n  }\n\n  // Opt-in: same tabs:next/previous actions, active from content. Focuses\n  // the header so subsequent presses cycle via the handler above.\n  useKeybindings(\n    {\n      'tabs:next': () => {\n        handleTabChange(1)\n        setHeaderFocused(true)\n      },\n      'tabs:previous': () => {\n        handleTabChange(-1)\n        setHeaderFocused(true)\n      },\n    },\n    {\n      context: 'Tabs',\n      isActive:\n        navFromContent &&\n        !headerFocused &&\n        optedIn &&\n        !hidden &&\n        !disableNavigation,\n    },\n  )\n\n  // Calculate spacing to fill the available width. No keyboard hint in the\n  // header row — content footers own hints (see useTabHeaderFocus docs).\n  const titleWidth = title ? stringWidth(title) + 1 : 0 // +1 for gap\n  const tabsWidth = tabs.reduce(\n    (sum, [, tabTitle]) => sum + (tabTitle ? stringWidth(tabTitle) : 0) + 2 + 1, // +2 for padding, +1 for gap\n    0,\n  )\n  const usedWidth = titleWidth + tabsWidth\n  const spacerWidth = useFullWidth ? Math.max(0, terminalWidth - usedWidth) : 0\n\n  const contentWidth = useFullWidth ? terminalWidth : undefined\n\n  return (\n    <TabsContext.Provider\n      value={{\n        selectedTab: tabs[selectedTabIndex]![0],\n        width: contentWidth,\n        headerFocused,\n        focusHeader,\n        blurHeader,\n        registerOptIn,\n      }}\n    >\n      <Box\n        flexDirection=\"column\"\n        tabIndex={0}\n        autoFocus\n        onKeyDown={handleKeyDown}\n        // flexShrink=0 inside modal slot — the modal's absolute Box has no\n        // explicit height (grows to fit, maxHeight cap), so flexGrow=1 here\n        // resolves to 0 on re-render and the body blanks on Down arrow.\n        // See #23592. Outside modal, leave layout alone.\n        flexShrink={modalScrollRef ? 0 : undefined}\n      >\n        {!hidden && (\n          <Box\n            flexDirection=\"row\"\n            gap={1}\n            flexShrink={modalScrollRef ? 0 : undefined}\n          >\n            {title !== undefined && (\n              <Text bold color={color}>\n                {title}\n              </Text>\n            )}\n            {tabs.map(([id, title], i) => {\n              const isCurrent = selectedTabIndex === i\n              const hasColorCursor = color && isCurrent && headerFocused\n              return (\n                <Text\n                  key={id}\n                  backgroundColor={hasColorCursor ? color : undefined}\n                  color={hasColorCursor ? 'inverseText' : undefined}\n                  inverse={isCurrent && !hasColorCursor}\n                  bold={isCurrent}\n                >\n                  {' '}\n                  {title}{' '}\n                </Text>\n              )\n            })}\n            {spacerWidth > 0 && <Text>{' '.repeat(spacerWidth)}</Text>}\n          </Box>\n        )}\n        {banner}\n        {modalScrollRef ? (\n          // Inside the modal slot: own the ScrollBox here so the tabs\n          // header row above sits OUTSIDE the scroll area — it can never\n          // scroll off. The ref reaches REPL's ScrollKeybindingHandler via\n          // ModalContext. Keyed by selectedTabIndex → remounts on tab\n          // switch, resetting scrollTop to 0 without scrollTo() timing games.\n          <Box width={contentWidth} marginTop={hidden ? 0 : 1} flexShrink={0}>\n            <ScrollBox\n              key={selectedTabIndex}\n              ref={modalScrollRef}\n              flexDirection=\"column\"\n              flexShrink={0}\n            >\n              {children}\n            </ScrollBox>\n          </Box>\n        ) : (\n          <Box\n            width={contentWidth}\n            marginTop={hidden ? 0 : 1}\n            height={contentHeight}\n            overflowY={contentHeight !== undefined ? 'hidden' : undefined}\n          >\n            {children}\n          </Box>\n        )}\n      </Box>\n    </TabsContext.Provider>\n  )\n}\n\ntype TabProps = {\n  title: string\n  id?: string\n  children: React.ReactNode\n}\n\nexport function Tab({ title, id, children }: TabProps): React.ReactNode {\n  const { selectedTab, width } = useContext(TabsContext)\n  const insideModal = useIsInsideModal()\n  if (selectedTab !== (id ?? title)) {\n    return null\n  }\n\n  return (\n    <Box width={width} flexShrink={insideModal ? 0 : undefined}>\n      {children}\n    </Box>\n  )\n}\n\nexport function useTabsWidth(): number | undefined {\n  const { width } = useContext(TabsContext)\n  return width\n}\n\n/**\n * Opt into header-focus gating. Returns the current header focus state and a\n * callback to hand focus back to the tab row. For a Select, pass\n * `isDisabled={headerFocused}` and `onUpFromFirstItem={focusHeader}`; keep the\n * parent Tabs' initialHeaderFocused at its default so tab/←/→ work on mount.\n *\n * Calling this hook registers a ↓-blurs-header opt-in on mount. Don't call it\n * above an early return that renders static text — ↓ will blur the header with\n * no onUpFromFirstItem to recover. Split the component so the hook only runs\n * when the Select renders.\n */\nexport function useTabHeaderFocus(): {\n  headerFocused: boolean\n  focusHeader: () => void\n  blurHeader: () => void\n} {\n  const { headerFocused, focusHeader, blurHeader, registerOptIn } =\n    useContext(TabsContext)\n  useEffect(registerOptIn, [registerOptIn])\n  return { headerFocused, focusHeader, blurHeader }\n}\n"],"mappings":"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","ignoreList":[]}