@xelauvas/xela-cli 0.1.0

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

@@ -0,0 +1,174 @@
+import { c as _c } from "react/compiler-runtime";
+import { feature } from 'bun:bundle';
+import React, { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import useStdin from '../../ink/hooks/use-stdin.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { getSystemThemeName, type SystemTheme } from '../../utils/systemTheme.js';
+import type { ThemeName, ThemeSetting } from '../../utils/theme.js';
+type ThemeContextValue = {
+  /** The saved user preference. May be 'auto'. */
+  themeSetting: ThemeSetting;
+  setThemeSetting: (setting: ThemeSetting) => void;
+  setPreviewTheme: (setting: ThemeSetting) => void;
+  savePreview: () => void;
+  cancelPreview: () => void;
+  /** The resolved theme to render with. Never 'auto'. */
+  currentTheme: ThemeName;
+};
+
+// Non-'auto' default so useTheme() works without a provider (tests, tooling).
+const DEFAULT_THEME: ThemeName = 'dark';
+const ThemeContext = createContext<ThemeContextValue>({
+  themeSetting: DEFAULT_THEME,
+  setThemeSetting: () => {},
+  setPreviewTheme: () => {},
+  savePreview: () => {},
+  cancelPreview: () => {},
+  currentTheme: DEFAULT_THEME
+});
+type Props = {
+  children: React.ReactNode;
+  initialState?: ThemeSetting;
+  onThemeSave?: (setting: ThemeSetting) => void;
+};
+function defaultInitialTheme(): ThemeSetting {
+  try {
+    return getGlobalConfig().theme || 'dark';
+  } catch {
+    return 'dark';
+  }
+}
+function defaultSaveTheme(setting: ThemeSetting): void {
+  saveGlobalConfig(current => ({
+    ...current,
+    theme: setting
+  }));
+}
+export function ThemeProvider({
+  children,
+  initialState,
+  onThemeSave = defaultSaveTheme
+}: Props) {
+  const [themeSetting, setThemeSetting] = useState(initialState ?? defaultInitialTheme);
+  const [previewTheme, setPreviewTheme] = useState<ThemeSetting | null>(null);
+
+  // Track terminal theme for 'auto' resolution. Seeds from $COLORFGBG (or
+  // 'dark' if unset); the OSC 11 watcher corrects it on first poll.
+  const [systemTheme, setSystemTheme] = useState<SystemTheme>(() => (initialState ?? themeSetting) === 'auto' ? getSystemThemeName() : 'dark');
+
+  // The setting currently in effect (preview wins while picker is open)
+  const activeSetting = previewTheme ?? themeSetting;
+  const {
+    internal_querier
+  } = useStdin();
+
+  // Watch for live terminal theme changes while 'auto' is active.
+  // Positive feature() pattern so the watcher import is dead-code-eliminated
+  // in external builds.
+  useEffect(() => {
+    if (feature('AUTO_THEME')) {
+      if (activeSetting !== 'auto' || !internal_querier) return;
+      let cleanup: (() => void) | undefined;
+      let cancelled = false;
+      void import('../../utils/systemThemeWatcher.js').then(({
+        watchSystemTheme
+      }) => {
+        if (cancelled) return;
+        cleanup = watchSystemTheme(internal_querier, setSystemTheme);
+      });
+      return () => {
+        cancelled = true;
+        cleanup?.();
+      };
+    }
+  }, [activeSetting, internal_querier]);
+  const currentTheme: ThemeName = activeSetting === 'auto' ? systemTheme : activeSetting;
+  const value = useMemo<ThemeContextValue>(() => ({
+    themeSetting,
+    setThemeSetting: (newSetting: ThemeSetting) => {
+      setThemeSetting(newSetting);
+      setPreviewTheme(null);
+      // Switching to 'auto' restarts the watcher (activeSetting dep), whose
+      // first poll fires immediately. Seed from the cache so the OSC
+      // round-trip doesn't flash the wrong palette.
+      if (newSetting === 'auto') {
+        setSystemTheme(getSystemThemeName());
+      }
+      onThemeSave?.(newSetting);
+    },
+    setPreviewTheme: (newSetting_0: ThemeSetting) => {
+      setPreviewTheme(newSetting_0);
+      if (newSetting_0 === 'auto') {
+        setSystemTheme(getSystemThemeName());
+      }
+    },
+    savePreview: () => {
+      if (previewTheme !== null) {
+        setThemeSetting(previewTheme);
+        setPreviewTheme(null);
+        onThemeSave?.(previewTheme);
+      }
+    },
+    cancelPreview: () => {
+      if (previewTheme !== null) {
+        setPreviewTheme(null);
+      }
+    },
+    currentTheme
+  }), [themeSetting, previewTheme, currentTheme, onThemeSave]);
+  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
+}
+
+/**
+ * Returns the resolved theme for rendering (never 'auto') and a setter that
+ * accepts any ThemeSetting (including 'auto').
+ */
+export function useTheme() {
+  const $ = _c(3);
+  const {
+    currentTheme,
+    setThemeSetting
+  } = useContext(ThemeContext);
+  let t0;
+  if ($[0] !== currentTheme || $[1] !== setThemeSetting) {
+    t0 = [currentTheme, setThemeSetting];
+    $[0] = currentTheme;
+    $[1] = setThemeSetting;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+
+/**
+ * Returns the raw theme setting as stored in config. Use this in UI that
+ * needs to show 'auto' as a distinct choice (e.g., ThemePicker).
+ */
+export function useThemeSetting() {
+  return useContext(ThemeContext).themeSetting;
+}
+export function usePreviewTheme() {
+  const $ = _c(4);
+  const {
+    setPreviewTheme,
+    savePreview,
+    cancelPreview
+  } = useContext(ThemeContext);
+  let t0;
+  if ($[0] !== cancelPreview || $[1] !== savePreview || $[2] !== setPreviewTheme) {
+    t0 = {
+      setPreviewTheme,
+      savePreview,
+      cancelPreview
+    };
+    $[0] = cancelPreview;
+    $[1] = savePreview;
+    $[2] = setPreviewTheme;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  return t0;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","createContext","useContext","useEffect","useMemo","useState","useStdin","getGlobalConfig","saveGlobalConfig","getSystemThemeName","SystemTheme","ThemeName","ThemeSetting","ThemeContextValue","themeSetting","setThemeSetting","setting","setPreviewTheme","savePreview","cancelPreview","currentTheme","DEFAULT_THEME","ThemeContext","Props","children","ReactNode","initialState","onThemeSave","defaultInitialTheme","theme","defaultSaveTheme","current","ThemeProvider","previewTheme","systemTheme","setSystemTheme","activeSetting","internal_querier","cleanup","cancelled","then","watchSystemTheme","value","newSetting","useTheme","$","_c","t0","useThemeSetting","usePreviewTheme"],"sources":["ThemeProvider.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport React, {\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react'\nimport useStdin from '../../ink/hooks/use-stdin.js'\nimport { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'\nimport {\n  getSystemThemeName,\n  type SystemTheme,\n} from '../../utils/systemTheme.js'\nimport type { ThemeName, ThemeSetting } from '../../utils/theme.js'\n\ntype ThemeContextValue = {\n  /** The saved user preference. May be 'auto'. */\n  themeSetting: ThemeSetting\n  setThemeSetting: (setting: ThemeSetting) => void\n  setPreviewTheme: (setting: ThemeSetting) => void\n  savePreview: () => void\n  cancelPreview: () => void\n  /** The resolved theme to render with. Never 'auto'. */\n  currentTheme: ThemeName\n}\n\n// Non-'auto' default so useTheme() works without a provider (tests, tooling).\nconst DEFAULT_THEME: ThemeName = 'dark'\n\nconst ThemeContext = createContext<ThemeContextValue>({\n  themeSetting: DEFAULT_THEME,\n  setThemeSetting: () => {},\n  setPreviewTheme: () => {},\n  savePreview: () => {},\n  cancelPreview: () => {},\n  currentTheme: DEFAULT_THEME,\n})\n\ntype Props = {\n  children: React.ReactNode\n  initialState?: ThemeSetting\n  onThemeSave?: (setting: ThemeSetting) => void\n}\n\nfunction defaultInitialTheme(): ThemeSetting {\n  return getGlobalConfig().theme\n}\n\nfunction defaultSaveTheme(setting: ThemeSetting): void {\n  saveGlobalConfig(current => ({ ...current, theme: setting }))\n}\n\nexport function ThemeProvider({\n  children,\n  initialState,\n  onThemeSave = defaultSaveTheme,\n}: Props) {\n  const [themeSetting, setThemeSetting] = useState(\n    initialState ?? defaultInitialTheme,\n  )\n  const [previewTheme, setPreviewTheme] = useState<ThemeSetting | null>(null)\n\n  // Track terminal theme for 'auto' resolution. Seeds from $COLORFGBG (or\n  // 'dark' if unset); the OSC 11 watcher corrects it on first poll.\n  const [systemTheme, setSystemTheme] = useState<SystemTheme>(() =>\n    (initialState ?? themeSetting) === 'auto' ? getSystemThemeName() : 'dark',\n  )\n\n  // The setting currently in effect (preview wins while picker is open)\n  const activeSetting = previewTheme ?? themeSetting\n\n  const { internal_querier } = useStdin()\n\n  // Watch for live terminal theme changes while 'auto' is active.\n  // Positive feature() pattern so the watcher import is dead-code-eliminated\n  // in external builds.\n  useEffect(() => {\n    if (feature('AUTO_THEME')) {\n      if (activeSetting !== 'auto' || !internal_querier) return\n      let cleanup: (() => void) | undefined\n      let cancelled = false\n      void import('../../utils/systemThemeWatcher.js').then(\n        ({ watchSystemTheme }) => {\n          if (cancelled) return\n          cleanup = watchSystemTheme(internal_querier, setSystemTheme)\n        },\n      )\n      return () => {\n        cancelled = true\n        cleanup?.()\n      }\n    }\n  }, [activeSetting, internal_querier])\n\n  const currentTheme: ThemeName =\n    activeSetting === 'auto' ? systemTheme : activeSetting\n\n  const value = useMemo<ThemeContextValue>(\n    () => ({\n      themeSetting,\n      setThemeSetting: (newSetting: ThemeSetting) => {\n        setThemeSetting(newSetting)\n        setPreviewTheme(null)\n        // Switching to 'auto' restarts the watcher (activeSetting dep), whose\n        // first poll fires immediately. Seed from the cache so the OSC\n        // round-trip doesn't flash the wrong palette.\n        if (newSetting === 'auto') {\n          setSystemTheme(getSystemThemeName())\n        }\n        onThemeSave?.(newSetting)\n      },\n      setPreviewTheme: (newSetting: ThemeSetting) => {\n        setPreviewTheme(newSetting)\n        if (newSetting === 'auto') {\n          setSystemTheme(getSystemThemeName())\n        }\n      },\n      savePreview: () => {\n        if (previewTheme !== null) {\n          setThemeSetting(previewTheme)\n          setPreviewTheme(null)\n          onThemeSave?.(previewTheme)\n        }\n      },\n      cancelPreview: () => {\n        if (previewTheme !== null) {\n          setPreviewTheme(null)\n        }\n      },\n      currentTheme,\n    }),\n    [themeSetting, previewTheme, currentTheme, onThemeSave],\n  )\n\n  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>\n}\n\n/**\n * Returns the resolved theme for rendering (never 'auto') and a setter that\n * accepts any ThemeSetting (including 'auto').\n */\nexport function useTheme(): [ThemeName, (setting: ThemeSetting) => void] {\n  const { currentTheme, setThemeSetting } = useContext(ThemeContext)\n  return [currentTheme, setThemeSetting]\n}\n\n/**\n * Returns the raw theme setting as stored in config. Use this in UI that\n * needs to show 'auto' as a distinct choice (e.g., ThemePicker).\n */\nexport function useThemeSetting(): ThemeSetting {\n  return useContext(ThemeContext).themeSetting\n}\n\nexport function usePreviewTheme() {\n  const { setPreviewTheme, savePreview, cancelPreview } =\n    useContext(ThemeContext)\n  return { setPreviewTheme, savePreview, cancelPreview }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,156 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { type PropsWithChildren, type Ref } from 'react';
+import Box from '../../ink/components/Box.js';
+import type { DOMElement } from '../../ink/dom.js';
+import type { ClickEvent } from '../../ink/events/click-event.js';
+import type { FocusEvent } from '../../ink/events/focus-event.js';
+import type { KeyboardEvent } from '../../ink/events/keyboard-event.js';
+import type { Color, Styles } from '../../ink/styles.js';
+import { getTheme, type Theme } from '../../utils/theme.js';
+import { useTheme } from './ThemeProvider.js';
+
+// Color props that accept theme keys
+type ThemedColorProps = {
+  readonly borderColor?: keyof Theme | Color;
+  readonly borderTopColor?: keyof Theme | Color;
+  readonly borderBottomColor?: keyof Theme | Color;
+  readonly borderLeftColor?: keyof Theme | Color;
+  readonly borderRightColor?: keyof Theme | Color;
+  readonly backgroundColor?: keyof Theme | Color;
+};
+
+// Base Styles without color props (they'll be overridden)
+type BaseStylesWithoutColors = Omit<Styles, 'textWrap' | 'borderColor' | 'borderTopColor' | 'borderBottomColor' | 'borderLeftColor' | 'borderRightColor' | 'backgroundColor'>;
+export type Props = BaseStylesWithoutColors & ThemedColorProps & {
+  ref?: Ref<DOMElement>;
+  tabIndex?: number;
+  autoFocus?: boolean;
+  onClick?: (event: ClickEvent) => void;
+  onFocus?: (event: FocusEvent) => void;
+  onFocusCapture?: (event: FocusEvent) => void;
+  onBlur?: (event: FocusEvent) => void;
+  onBlurCapture?: (event: FocusEvent) => void;
+  onKeyDown?: (event: KeyboardEvent) => void;
+  onKeyDownCapture?: (event: KeyboardEvent) => void;
+  onMouseEnter?: () => void;
+  onMouseLeave?: () => void;
+};
+
+/**
+ * Resolves a color value that may be a theme key to a raw Color.
+ */
+function resolveColor(color: keyof Theme | Color | undefined, theme: Theme): Color | undefined {
+  if (!color) return undefined;
+  // Check if it's a raw color (starts with rgb(, #, ansi256(, or ansi:)
+  if (color.startsWith('rgb(') || color.startsWith('#') || color.startsWith('ansi256(') || color.startsWith('ansi:')) {
+    return color as Color;
+  }
+  // It's a theme key - resolve it
+  return theme[color as keyof Theme] as Color;
+}
+
+/**
+ * Theme-aware Box component that resolves theme color keys to raw colors.
+ * This wraps the base Box component with theme resolution for border colors.
+ */
+function ThemedBox(t0) {
+  const $ = _c(33);
+  let backgroundColor;
+  let borderBottomColor;
+  let borderColor;
+  let borderLeftColor;
+  let borderRightColor;
+  let borderTopColor;
+  let children;
+  let ref;
+  let rest;
+  if ($[0] !== t0) {
+    ({
+      borderColor,
+      borderTopColor,
+      borderBottomColor,
+      borderLeftColor,
+      borderRightColor,
+      backgroundColor,
+      children,
+      ref,
+      ...rest
+    } = t0);
+    $[0] = t0;
+    $[1] = backgroundColor;
+    $[2] = borderBottomColor;
+    $[3] = borderColor;
+    $[4] = borderLeftColor;
+    $[5] = borderRightColor;
+    $[6] = borderTopColor;
+    $[7] = children;
+    $[8] = ref;
+    $[9] = rest;
+  } else {
+    backgroundColor = $[1];
+    borderBottomColor = $[2];
+    borderColor = $[3];
+    borderLeftColor = $[4];
+    borderRightColor = $[5];
+    borderTopColor = $[6];
+    children = $[7];
+    ref = $[8];
+    rest = $[9];
+  }
+  const [themeName] = useTheme();
+  let resolvedBorderBottomColor;
+  let resolvedBorderColor;
+  let resolvedBorderLeftColor;
+  let resolvedBorderRightColor;
+  let resolvedBorderTopColor;
+  let t1;
+  if ($[10] !== backgroundColor || $[11] !== borderBottomColor || $[12] !== borderColor || $[13] !== borderLeftColor || $[14] !== borderRightColor || $[15] !== borderTopColor || $[16] !== themeName) {
+    const theme = getTheme(themeName);
+    resolvedBorderColor = resolveColor(borderColor, theme);
+    resolvedBorderTopColor = resolveColor(borderTopColor, theme);
+    resolvedBorderBottomColor = resolveColor(borderBottomColor, theme);
+    resolvedBorderLeftColor = resolveColor(borderLeftColor, theme);
+    resolvedBorderRightColor = resolveColor(borderRightColor, theme);
+    t1 = resolveColor(backgroundColor, theme);
+    $[10] = backgroundColor;
+    $[11] = borderBottomColor;
+    $[12] = borderColor;
+    $[13] = borderLeftColor;
+    $[14] = borderRightColor;
+    $[15] = borderTopColor;
+    $[16] = themeName;
+    $[17] = resolvedBorderBottomColor;
+    $[18] = resolvedBorderColor;
+    $[19] = resolvedBorderLeftColor;
+    $[20] = resolvedBorderRightColor;
+    $[21] = resolvedBorderTopColor;
+    $[22] = t1;
+  } else {
+    resolvedBorderBottomColor = $[17];
+    resolvedBorderColor = $[18];
+    resolvedBorderLeftColor = $[19];
+    resolvedBorderRightColor = $[20];
+    resolvedBorderTopColor = $[21];
+    t1 = $[22];
+  }
+  const resolvedBackgroundColor = t1;
+  let t2;
+  if ($[23] !== children || $[24] !== ref || $[25] !== resolvedBackgroundColor || $[26] !== resolvedBorderBottomColor || $[27] !== resolvedBorderColor || $[28] !== resolvedBorderLeftColor || $[29] !== resolvedBorderRightColor || $[30] !== resolvedBorderTopColor || $[31] !== rest) {
+    t2 = <Box ref={ref} borderColor={resolvedBorderColor} borderTopColor={resolvedBorderTopColor} borderBottomColor={resolvedBorderBottomColor} borderLeftColor={resolvedBorderLeftColor} borderRightColor={resolvedBorderRightColor} backgroundColor={resolvedBackgroundColor} {...rest}>{children}</Box>;
+    $[23] = children;
+    $[24] = ref;
+    $[25] = resolvedBackgroundColor;
+    $[26] = resolvedBorderBottomColor;
+    $[27] = resolvedBorderColor;
+    $[28] = resolvedBorderLeftColor;
+    $[29] = resolvedBorderRightColor;
+    $[30] = resolvedBorderTopColor;
+    $[31] = rest;
+    $[32] = t2;
+  } else {
+    t2 = $[32];
+  }
+  return t2;
+}
+export default ThemedBox;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","PropsWithChildren","Ref","Box","DOMElement","ClickEvent","FocusEvent","KeyboardEvent","Color","Styles","getTheme","Theme","useTheme","ThemedColorProps","borderColor","borderTopColor","borderBottomColor","borderLeftColor","borderRightColor","backgroundColor","BaseStylesWithoutColors","Omit","Props","ref","tabIndex","autoFocus","onClick","event","onFocus","onFocusCapture","onBlur","onBlurCapture","onKeyDown","onKeyDownCapture","onMouseEnter","onMouseLeave","resolveColor","color","theme","undefined","startsWith","ThemedBox","t0","$","_c","children","rest","themeName","resolvedBorderBottomColor","resolvedBorderColor","resolvedBorderLeftColor","resolvedBorderRightColor","resolvedBorderTopColor","t1","resolvedBackgroundColor","t2"],"sources":["ThemedBox.tsx"],"sourcesContent":["import React, { type PropsWithChildren, type Ref } from 'react'\nimport Box from '../../ink/components/Box.js'\nimport type { DOMElement } from '../../ink/dom.js'\nimport type { ClickEvent } from '../../ink/events/click-event.js'\nimport type { FocusEvent } from '../../ink/events/focus-event.js'\nimport type { KeyboardEvent } from '../../ink/events/keyboard-event.js'\nimport type { Color, Styles } from '../../ink/styles.js'\nimport { getTheme, type Theme } from '../../utils/theme.js'\nimport { useTheme } from './ThemeProvider.js'\n\n// Color props that accept theme keys\ntype ThemedColorProps = {\n  readonly borderColor?: keyof Theme | Color\n  readonly borderTopColor?: keyof Theme | Color\n  readonly borderBottomColor?: keyof Theme | Color\n  readonly borderLeftColor?: keyof Theme | Color\n  readonly borderRightColor?: keyof Theme | Color\n  readonly backgroundColor?: keyof Theme | Color\n}\n\n// Base Styles without color props (they'll be overridden)\ntype BaseStylesWithoutColors = Omit<\n  Styles,\n  | 'textWrap'\n  | 'borderColor'\n  | 'borderTopColor'\n  | 'borderBottomColor'\n  | 'borderLeftColor'\n  | 'borderRightColor'\n  | 'backgroundColor'\n>\n\nexport type Props = BaseStylesWithoutColors &\n  ThemedColorProps & {\n    ref?: Ref<DOMElement>\n    tabIndex?: number\n    autoFocus?: boolean\n    onClick?: (event: ClickEvent) => void\n    onFocus?: (event: FocusEvent) => void\n    onFocusCapture?: (event: FocusEvent) => void\n    onBlur?: (event: FocusEvent) => void\n    onBlurCapture?: (event: FocusEvent) => void\n    onKeyDown?: (event: KeyboardEvent) => void\n    onKeyDownCapture?: (event: KeyboardEvent) => void\n    onMouseEnter?: () => void\n    onMouseLeave?: () => void\n  }\n\n/**\n * Resolves a color value that may be a theme key to a raw Color.\n */\nfunction resolveColor(\n  color: keyof Theme | Color | undefined,\n  theme: Theme,\n): Color | undefined {\n  if (!color) return undefined\n  // Check if it's a raw color (starts with rgb(, #, ansi256(, or ansi:)\n  if (\n    color.startsWith('rgb(') ||\n    color.startsWith('#') ||\n    color.startsWith('ansi256(') ||\n    color.startsWith('ansi:')\n  ) {\n    return color as Color\n  }\n  // It's a theme key - resolve it\n  return theme[color as keyof Theme] as Color\n}\n\n/**\n * Theme-aware Box component that resolves theme color keys to raw colors.\n * This wraps the base Box component with theme resolution for border colors.\n */\nfunction ThemedBox({\n  borderColor,\n  borderTopColor,\n  borderBottomColor,\n  borderLeftColor,\n  borderRightColor,\n  backgroundColor,\n  children,\n  ref,\n  ...rest\n}: PropsWithChildren<Props>): React.ReactNode {\n  const [themeName] = useTheme()\n  const theme = getTheme(themeName)\n\n  // Resolve theme keys to raw colors\n  const resolvedBorderColor = resolveColor(borderColor, theme)\n  const resolvedBorderTopColor = resolveColor(borderTopColor, theme)\n  const resolvedBorderBottomColor = resolveColor(borderBottomColor, theme)\n  const resolvedBorderLeftColor = resolveColor(borderLeftColor, theme)\n  const resolvedBorderRightColor = resolveColor(borderRightColor, theme)\n  const resolvedBackgroundColor = resolveColor(backgroundColor, theme)\n\n  return (\n    <Box\n      ref={ref}\n      borderColor={resolvedBorderColor}\n      borderTopColor={resolvedBorderTopColor}\n      borderBottomColor={resolvedBorderBottomColor}\n      borderLeftColor={resolvedBorderLeftColor}\n      borderRightColor={resolvedBorderRightColor}\n      backgroundColor={resolvedBackgroundColor}\n      {...rest}\n    >\n      {children}\n    </Box>\n  )\n}\n\nexport default ThemedBox\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,124 @@
+import { c as _c } from "react/compiler-runtime";
+import type { ReactNode } from 'react';
+import React, { useContext } from 'react';
+import Text from '../../ink/components/Text.js';
+import type { Color, Styles } from '../../ink/styles.js';
+import { getTheme, type Theme } from '../../utils/theme.js';
+import { useTheme } from './ThemeProvider.js';
+
+/** Colors uncolored ThemedText in the subtree. Precedence: explicit `color` >
+ *  this > dimColor. Crosses Box boundaries (Ink's style cascade doesn't). */
+export const TextHoverColorContext = React.createContext<keyof Theme | undefined>(undefined);
+export type Props = {
+  /**
+   * Change text color. Accepts a theme key or raw color value.
+   */
+  readonly color?: keyof Theme | Color;
+
+  /**
+   * Same as `color`, but for background. Must be a theme key.
+   */
+  readonly backgroundColor?: keyof Theme;
+
+  /**
+   * Dim the color using the theme's inactive color.
+   * This is compatible with bold (unlike ANSI dim).
+   */
+  readonly dimColor?: boolean;
+
+  /**
+   * Make the text bold.
+   */
+  readonly bold?: boolean;
+
+  /**
+   * Make the text italic.
+   */
+  readonly italic?: boolean;
+
+  /**
+   * Make the text underlined.
+   */
+  readonly underline?: boolean;
+
+  /**
+   * Make the text crossed with a line.
+   */
+  readonly strikethrough?: boolean;
+
+  /**
+   * Inverse background and foreground colors.
+   */
+  readonly inverse?: boolean;
+
+  /**
+   * This property tells Ink to wrap or truncate text if its width is larger than container.
+   * If `wrap` is passed (by default), Ink will wrap text and split it into multiple lines.
+   * If `truncate-*` is passed, Ink will truncate text instead, which will result in one line of text with the rest cut off.
+   */
+  readonly wrap?: Styles['textWrap'];
+  readonly children?: ReactNode;
+};
+
+/**
+ * Resolves a color value that may be a theme key to a raw Color.
+ */
+function resolveColor(color: keyof Theme | Color | undefined, theme: Theme): Color | undefined {
+  if (!color) return undefined;
+  // Check if it's a raw color (starts with rgb(, #, ansi256(, or ansi:)
+  if (color.startsWith('rgb(') || color.startsWith('#') || color.startsWith('ansi256(') || color.startsWith('ansi:')) {
+    return color as Color;
+  }
+  // It's a theme key - resolve it
+  return theme[color as keyof Theme] as Color;
+}
+
+/**
+ * Theme-aware Text component that resolves theme color keys to raw colors.
+ * This wraps the base Text component with theme resolution.
+ */
+export default function ThemedText(t0) {
+  const $ = _c(10);
+  const {
+    color,
+    backgroundColor,
+    dimColor: t1,
+    bold: t2,
+    italic: t3,
+    underline: t4,
+    strikethrough: t5,
+    inverse: t6,
+    wrap: t7,
+    children
+  } = t0;
+  const dimColor = t1 === undefined ? false : t1;
+  const bold = t2 === undefined ? false : t2;
+  const italic = t3 === undefined ? false : t3;
+  const underline = t4 === undefined ? false : t4;
+  const strikethrough = t5 === undefined ? false : t5;
+  const inverse = t6 === undefined ? false : t6;
+  const wrap = t7 === undefined ? "wrap" : t7;
+  const [themeName] = useTheme();
+  const theme = getTheme(themeName);
+  const hoverColor = useContext(TextHoverColorContext);
+  const resolvedColor = !color && hoverColor ? resolveColor(hoverColor, theme) : dimColor ? theme.inactive as Color : resolveColor(color, theme);
+  const resolvedBackgroundColor = backgroundColor ? theme[backgroundColor] as Color : undefined;
+  let t8;
+  if ($[0] !== bold || $[1] !== children || $[2] !== inverse || $[3] !== italic || $[4] !== resolvedBackgroundColor || $[5] !== resolvedColor || $[6] !== strikethrough || $[7] !== underline || $[8] !== wrap) {
+    t8 = <Text color={resolvedColor} backgroundColor={resolvedBackgroundColor} bold={bold} italic={italic} underline={underline} strikethrough={strikethrough} inverse={inverse} wrap={wrap}>{children}</Text>;
+    $[0] = bold;
+    $[1] = children;
+    $[2] = inverse;
+    $[3] = italic;
+    $[4] = resolvedBackgroundColor;
+    $[5] = resolvedColor;
+    $[6] = strikethrough;
+    $[7] = underline;
+    $[8] = wrap;
+    $[9] = t8;
+  } else {
+    t8 = $[9];
+  }
+  return t8;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ReactNode","React","useContext","Text","Color","Styles","getTheme","Theme","useTheme","TextHoverColorContext","createContext","undefined","Props","color","backgroundColor","dimColor","bold","italic","underline","strikethrough","inverse","wrap","children","resolveColor","theme","startsWith","ThemedText","t0","$","_c","t1","t2","t3","t4","t5","t6","t7","themeName","hoverColor","resolvedColor","inactive","resolvedBackgroundColor","t8"],"sources":["ThemedText.tsx"],"sourcesContent":["import type { ReactNode } from 'react'\nimport React, { useContext } from 'react'\nimport Text from '../../ink/components/Text.js'\nimport type { Color, Styles } from '../../ink/styles.js'\nimport { getTheme, type Theme } from '../../utils/theme.js'\nimport { useTheme } from './ThemeProvider.js'\n\n/** Colors uncolored ThemedText in the subtree. Precedence: explicit `color` >\n *  this > dimColor. Crosses Box boundaries (Ink's style cascade doesn't). */\nexport const TextHoverColorContext = React.createContext<\n  keyof Theme | undefined\n>(undefined)\n\nexport type Props = {\n  /**\n   * Change text color. Accepts a theme key or raw color value.\n   */\n  readonly color?: keyof Theme | Color\n\n  /**\n   * Same as `color`, but for background. Must be a theme key.\n   */\n  readonly backgroundColor?: keyof Theme\n\n  /**\n   * Dim the color using the theme's inactive color.\n   * This is compatible with bold (unlike ANSI dim).\n   */\n  readonly dimColor?: boolean\n\n  /**\n   * Make the text bold.\n   */\n  readonly bold?: boolean\n\n  /**\n   * Make the text italic.\n   */\n  readonly italic?: boolean\n\n  /**\n   * Make the text underlined.\n   */\n  readonly underline?: boolean\n\n  /**\n   * Make the text crossed with a line.\n   */\n  readonly strikethrough?: boolean\n\n  /**\n   * Inverse background and foreground colors.\n   */\n  readonly inverse?: boolean\n\n  /**\n   * This property tells Ink to wrap or truncate text if its width is larger than container.\n   * If `wrap` is passed (by default), Ink will wrap text and split it into multiple lines.\n   * If `truncate-*` is passed, Ink will truncate text instead, which will result in one line of text with the rest cut off.\n   */\n  readonly wrap?: Styles['textWrap']\n\n  readonly children?: ReactNode\n}\n\n/**\n * Resolves a color value that may be a theme key to a raw Color.\n */\nfunction resolveColor(\n  color: keyof Theme | Color | undefined,\n  theme: Theme,\n): Color | undefined {\n  if (!color) return undefined\n  // Check if it's a raw color (starts with rgb(, #, ansi256(, or ansi:)\n  if (\n    color.startsWith('rgb(') ||\n    color.startsWith('#') ||\n    color.startsWith('ansi256(') ||\n    color.startsWith('ansi:')\n  ) {\n    return color as Color\n  }\n  // It's a theme key - resolve it\n  return theme[color as keyof Theme] as Color\n}\n\n/**\n * Theme-aware Text component that resolves theme color keys to raw colors.\n * This wraps the base Text component with theme resolution.\n */\nexport default function ThemedText({\n  color,\n  backgroundColor,\n  dimColor = false,\n  bold = false,\n  italic = false,\n  underline = false,\n  strikethrough = false,\n  inverse = false,\n  wrap = 'wrap',\n  children,\n}: Props): React.ReactNode {\n  const [themeName] = useTheme()\n  const theme = getTheme(themeName)\n  const hoverColor = useContext(TextHoverColorContext)\n\n  // Resolve theme keys to raw colors\n  const resolvedColor =\n    !color && hoverColor\n      ? resolveColor(hoverColor, theme)\n      : dimColor\n        ? (theme.inactive as Color)\n        : resolveColor(color, theme)\n  const resolvedBackgroundColor = backgroundColor\n    ? (theme[backgroundColor] as Color)\n    : undefined\n\n  return (\n    <Text\n      color={resolvedColor}\n      backgroundColor={resolvedBackgroundColor}\n      bold={bold}\n      italic={italic}\n      underline={underline}\n      strikethrough={strikethrough}\n      inverse={inverse}\n      wrap={wrap}\n    >\n      {children}\n    </Text>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/design-system/color.ts

@@ -0,0 +1,30 @@
+import { type ColorType, colorize } from '../../ink/colorize.js'
+import type { Color } from '../../ink/styles.js'
+import { getTheme, type Theme, type ThemeName } from '../../utils/theme.js'
+
+/**
+ * Curried theme-aware color function. Resolves theme keys to raw color
+ * values before delegating to the ink renderer's colorize.
+ */
+export function color(
+  c: keyof Theme | Color | undefined,
+  theme: ThemeName,
+  type: ColorType = 'foreground',
+): (text: string) => string {
+  return text => {
+    if (!c) {
+      return text
+    }
+    // Raw color values bypass theme lookup
+    if (
+      c.startsWith('rgb(') ||
+      c.startsWith('#') ||
+      c.startsWith('ansi256(') ||
+      c.startsWith('ansi:')
+    ) {
+      return colorize(text, c, type)
+    }
+    // Theme key lookup
+    return colorize(text, getTheme(theme)[c as keyof Theme], type)
+  }
+}