termui 0.1.0 → 0.1.2

package/dist/chunk-ZZKFZA2U.js

@@ -0,0 +1,694 @@
+// packages/core/src/terminal/ansi.js
+var ESC = "\x1B";
+var reset = `${ESC}[0m`;
+var bold = `${ESC}[1m`;
+var dim = `${ESC}[2m`;
+var italic = `${ESC}[3m`;
+var underline = `${ESC}[4m`;
+var blink = `${ESC}[5m`;
+var inverse = `${ESC}[7m`;
+var hidden = `${ESC}[8m`;
+var strikethrough = `${ESC}[9m`;
+var fg = {
+  black: `${ESC}[30m`,
+  red: `${ESC}[31m`,
+  green: `${ESC}[32m`,
+  yellow: `${ESC}[33m`,
+  blue: `${ESC}[34m`,
+  magenta: `${ESC}[35m`,
+  cyan: `${ESC}[36m`,
+  white: `${ESC}[37m`,
+  default: `${ESC}[39m`,
+  // Bright variants (90–97)
+  brightBlack: `${ESC}[90m`,
+  brightRed: `${ESC}[91m`,
+  brightGreen: `${ESC}[92m`,
+  brightYellow: `${ESC}[93m`,
+  brightBlue: `${ESC}[94m`,
+  brightMagenta: `${ESC}[95m`,
+  brightCyan: `${ESC}[96m`,
+  brightWhite: `${ESC}[97m`
+};
+var bg = {
+  black: `${ESC}[40m`,
+  red: `${ESC}[41m`,
+  green: `${ESC}[42m`,
+  yellow: `${ESC}[43m`,
+  blue: `${ESC}[44m`,
+  magenta: `${ESC}[45m`,
+  cyan: `${ESC}[46m`,
+  white: `${ESC}[47m`,
+  default: `${ESC}[49m`,
+  // Bright backgrounds
+  brightBlack: `${ESC}[100m`,
+  brightRed: `${ESC}[101m`,
+  brightGreen: `${ESC}[102m`,
+  brightYellow: `${ESC}[103m`,
+  brightBlue: `${ESC}[104m`,
+  brightMagenta: `${ESC}[105m`,
+  brightCyan: `${ESC}[106m`,
+  brightWhite: `${ESC}[107m`
+};
+function fg256(n) {
+  return `${ESC}[38;5;${n}m`;
+}
+function bg256(n) {
+  return `${ESC}[48;5;${n}m`;
+}
+function fgRgb(r, g, b) {
+  return `${ESC}[38;2;${r};${g};${b}m`;
+}
+function bgRgb(r, g, b) {
+  return `${ESC}[48;2;${r};${g};${b}m`;
+}
+function parseHex(hex) {
+  const clean = hex.replace("#", "");
+  if (clean.length === 3) {
+    const r2 = parseInt(clean[0] + clean[0], 16);
+    const g2 = parseInt(clean[1] + clean[1], 16);
+    const b2 = parseInt(clean[2] + clean[2], 16);
+    return { r: r2, g: g2, b: b2 };
+  }
+  const r = parseInt(clean.slice(0, 2), 16);
+  const g = parseInt(clean.slice(2, 4), 16);
+  const b = parseInt(clean.slice(4, 6), 16);
+  return { r, g, b };
+}
+function fgHex(hex) {
+  const { r, g, b } = parseHex(hex);
+  return fgRgb(r, g, b);
+}
+function bgHex(hex) {
+  const { r, g, b } = parseHex(hex);
+  return bgRgb(r, g, b);
+}
+var cursor = {
+  up: (n = 1) => `${ESC}[${n}A`,
+  down: (n = 1) => `${ESC}[${n}B`,
+  forward: (n = 1) => `${ESC}[${n}C`,
+  back: (n = 1) => `${ESC}[${n}D`,
+  nextLine: (n = 1) => `${ESC}[${n}E`,
+  prevLine: (n = 1) => `${ESC}[${n}F`,
+  column: (n = 1) => `${ESC}[${n}G`,
+  position: (row, col) => `${ESC}[${row};${col}H`,
+  hide: `${ESC}[?25l`,
+  show: `${ESC}[?25h`,
+  save: `${ESC}[s`,
+  restore: `${ESC}[u`
+};
+var screen = {
+  clear: `${ESC}[2J`,
+  clearToEnd: `${ESC}[0J`,
+  clearToStart: `${ESC}[1J`,
+  clearLine: `${ESC}[2K`,
+  clearLineToEnd: `${ESC}[0K`,
+  clearLineToStart: `${ESC}[1K`,
+  alternateBuffer: `${ESC}[?1049h`,
+  mainBuffer: `${ESC}[?1049l`
+};
+var osc = {
+  /** OSC 8 — hyperlink: \x1b]8;;url\x1b\\ text \x1b]8;;\x1b\\ */
+  hyperlink: (url, text) => `${ESC}]8;;${url}${ESC}\\${text}${ESC}]8;;${ESC}\\`,
+  /** OSC 52 — clipboard write (base64-encoded) */
+  clipboardWrite: (data) => {
+    const encoded = Buffer.from(data).toString("base64");
+    return `${ESC}]52;c;${encoded}\x07`;
+  },
+  /** OSC 0 — set window title */
+  setTitle: (title) => `${ESC}]0;${title}\x07`
+};
+function style(code, text) {
+  return `${code}${text}${reset}`;
+}
+var ANSI_REGEX = /\x1b\[[0-9;]*[mGKHFABCDJn]|\x1b\][^\\]*\x1b\\|\x1b[()][AB012]/g;
+function stripAnsi(str) {
+  return str.replace(ANSI_REGEX, "");
+}
+function visibleWidth(str) {
+  return stripAnsi(str).length;
+}
+
+// packages/core/src/terminal/capabilities.js
+function detectCapabilities() {
+  const isTTY = Boolean(process.stdout.isTTY);
+  const columns = process.stdout.columns ?? 80;
+  const rows = process.stdout.rows ?? 24;
+  const noColor = "NO_COLOR" in process.env;
+  const forceColor = process.env["FORCE_COLOR"];
+  let colorDepth = 1;
+  if (!noColor) {
+    if (forceColor === "3" || forceColor === "true" || forceColor === "1") {
+      colorDepth = 24;
+    } else if (forceColor === "2") {
+      colorDepth = 8;
+    } else if (isTTY) {
+      const colorterm = (process.env["COLORTERM"] ?? "").toLowerCase();
+      if (colorterm === "truecolor" || colorterm === "24bit") {
+        colorDepth = 24;
+      } else if ((process.env["TERM_PROGRAM"] ?? "").toLowerCase().includes("iterm") || (process.env["TERM_PROGRAM"] ?? "").toLowerCase() === "hyper") {
+        colorDepth = 24;
+      } else if ((process.env["TERM"] ?? "").includes("256color")) {
+        colorDepth = 8;
+      } else if (process.env["TERM"] === "xterm" || isTTY) {
+        colorDepth = 4;
+      }
+    }
+  }
+  const supportsTrueColor = colorDepth === 24;
+  const supports256Color = colorDepth >= 8;
+  const lang = process.env["LANG"] ?? process.env["LC_ALL"] ?? "";
+  const supportsUnicode = lang.toLowerCase().includes("utf-8") || lang.toLowerCase().includes("utf8") || process.platform === "darwin" || (process.env["TERM_PROGRAM"] ?? "") !== "";
+  const supportsMouse = isTTY;
+  return {
+    colorDepth,
+    supportsUnicode,
+    supportsTrueColor,
+    supports256Color,
+    supportsMouse,
+    columns,
+    rows,
+    isTTY
+  };
+}
+var _capabilities = null;
+function getCapabilities() {
+  if (!_capabilities) {
+    _capabilities = detectCapabilities();
+  }
+  return _capabilities;
+}
+function refreshCapabilities() {
+  _capabilities = detectCapabilities();
+  return _capabilities;
+}
+
+// packages/core/src/styling/themes/default.js
+var defaultTheme = {
+  name: "default",
+  colors: {
+    primary: "#7C3AED",
+    primaryForeground: "#FFFFFF",
+    secondary: "#6B7280",
+    secondaryForeground: "#FFFFFF",
+    accent: "#8B5CF6",
+    accentForeground: "#FFFFFF",
+    success: "#10B981",
+    successForeground: "#FFFFFF",
+    warning: "#F59E0B",
+    warningForeground: "#000000",
+    error: "#EF4444",
+    errorForeground: "#FFFFFF",
+    info: "#3B82F6",
+    infoForeground: "#FFFFFF",
+    background: "#000000",
+    foreground: "#FFFFFF",
+    muted: "#374151",
+    mutedForeground: "#9CA3AF",
+    border: "#4B5563",
+    focusRing: "#8B5CF6",
+    selection: "#7C3AED",
+    selectionForeground: "#FFFFFF"
+  },
+  spacing: {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    6: 6,
+    8: 8
+  },
+  typography: {
+    bold: true,
+    sm: "dim",
+    base: "",
+    lg: "bold",
+    xl: "bold"
+  },
+  border: {
+    style: "round",
+    color: "#4B5563",
+    focusColor: "#8B5CF6"
+  }
+};
+
+// packages/core/src/styling/ThemeProvider.js
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext } from "react";
+var ThemeContext = createContext({
+  theme: defaultTheme,
+  setTheme: () => {
+  }
+});
+function ThemeProvider({ theme = defaultTheme, children }) {
+  const [currentTheme, setCurrentTheme] = React.useState(theme);
+  React.useEffect(() => {
+    setCurrentTheme(theme);
+  }, [theme]);
+  return _jsx(ThemeContext.Provider, { value: { theme: currentTheme, setTheme: setCurrentTheme }, children });
+}
+function useTheme() {
+  return useContext(ThemeContext).theme;
+}
+function useThemeUpdater() {
+  return useContext(ThemeContext).setTheme;
+}
+function createTheme(overrides) {
+  return {
+    ...defaultTheme,
+    ...overrides,
+    colors: {
+      ...defaultTheme.colors,
+      ...overrides.colors ?? {}
+    },
+    spacing: {
+      ...defaultTheme.spacing,
+      ...overrides.spacing ?? {}
+    },
+    typography: {
+      ...defaultTheme.typography,
+      ...overrides.typography ?? {}
+    },
+    border: {
+      ...defaultTheme.border,
+      ...overrides.border ?? {}
+    }
+  };
+}
+
+// packages/core/src/styling/style.js
+var StyleBuilder = class {
+  _text;
+  _codes = [];
+  constructor(text) {
+    this._text = text;
+  }
+  bold() {
+    this._codes.push(bold);
+    return this;
+  }
+  dim() {
+    this._codes.push(dim);
+    return this;
+  }
+  italic() {
+    this._codes.push(italic);
+    return this;
+  }
+  underline() {
+    this._codes.push(underline);
+    return this;
+  }
+  strikethrough() {
+    this._codes.push(strikethrough);
+    return this;
+  }
+  fg(color) {
+    this._codes.push(fgHex(color));
+    return this;
+  }
+  bg(color) {
+    this._codes.push(bgHex(color));
+    return this;
+  }
+  /** Build the final ANSI-styled string */
+  build() {
+    if (this._codes.length === 0)
+      return this._text;
+    return `${this._codes.join("")}${this._text}${reset}`;
+  }
+  toString() {
+    return this.build();
+  }
+};
+function style2(text) {
+  return new StyleBuilder(text);
+}
+
+// packages/core/src/styling/themes/dracula.js
+var draculaTheme = {
+  name: "dracula",
+  colors: {
+    primary: "#BD93F9",
+    primaryForeground: "#282A36",
+    secondary: "#6272A4",
+    secondaryForeground: "#F8F8F2",
+    accent: "#FF79C6",
+    accentForeground: "#282A36",
+    success: "#50FA7B",
+    successForeground: "#282A36",
+    warning: "#F1FA8C",
+    warningForeground: "#282A36",
+    error: "#FF5555",
+    errorForeground: "#F8F8F2",
+    info: "#8BE9FD",
+    infoForeground: "#282A36",
+    background: "#282A36",
+    foreground: "#F8F8F2",
+    muted: "#44475A",
+    mutedForeground: "#6272A4",
+    border: "#6272A4",
+    focusRing: "#BD93F9",
+    selection: "#44475A",
+    selectionForeground: "#F8F8F2"
+  },
+  spacing: {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    6: 6,
+    8: 8
+  },
+  typography: {
+    bold: true,
+    sm: "dim",
+    base: "",
+    lg: "bold",
+    xl: "bold"
+  },
+  border: {
+    style: "round",
+    color: "#6272A4",
+    focusColor: "#BD93F9"
+  }
+};
+
+// packages/core/src/styling/themes/nord.js
+var nordTheme = {
+  name: "nord",
+  colors: {
+    primary: "#88C0D0",
+    primaryForeground: "#2E3440",
+    secondary: "#4C566A",
+    secondaryForeground: "#ECEFF4",
+    accent: "#81A1C1",
+    accentForeground: "#2E3440",
+    success: "#A3BE8C",
+    successForeground: "#2E3440",
+    warning: "#EBCB8B",
+    warningForeground: "#2E3440",
+    error: "#BF616A",
+    errorForeground: "#ECEFF4",
+    info: "#5E81AC",
+    infoForeground: "#ECEFF4",
+    background: "#2E3440",
+    foreground: "#ECEFF4",
+    muted: "#3B4252",
+    mutedForeground: "#4C566A",
+    border: "#4C566A",
+    focusRing: "#88C0D0",
+    selection: "#3B4252",
+    selectionForeground: "#ECEFF4"
+  },
+  spacing: {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    6: 6,
+    8: 8
+  },
+  typography: {
+    bold: true,
+    sm: "dim",
+    base: "",
+    lg: "bold",
+    xl: "bold"
+  },
+  border: {
+    style: "round",
+    color: "#4C566A",
+    focusColor: "#88C0D0"
+  }
+};
+
+// packages/core/src/hooks/useInput.js
+import { useInput as inkUseInput } from "ink";
+function useInput(handler, options) {
+  inkUseInput(handler, options);
+}
+
+// packages/core/src/hooks/useFocus.js
+import { useFocus as inkUseFocus } from "ink";
+function useFocus(options) {
+  return inkUseFocus(options);
+}
+
+// packages/core/src/hooks/useFocusManager.js
+import { useFocusManager as inkUseFocusManager } from "ink";
+function useFocusManager() {
+  return inkUseFocusManager();
+}
+
+// packages/core/src/hooks/useTerminal.js
+import { useState, useEffect } from "react";
+function useTerminal() {
+  const [caps, setCaps] = useState(getCapabilities);
+  useEffect(() => {
+    const handler = () => {
+      setCaps(refreshCapabilities());
+    };
+    process.stdout.on("resize", handler);
+    return () => {
+      process.stdout.off("resize", handler);
+    };
+  }, []);
+  return caps;
+}
+
+// packages/core/src/hooks/useAnimation.js
+import { useState as useState2, useEffect as useEffect2, useRef } from "react";
+function useAnimation(fps = 12) {
+  const [frame, setFrame] = useState2(0);
+  const intervalRef = useRef(null);
+  useEffect2(() => {
+    const ms = Math.round(1e3 / fps);
+    intervalRef.current = setInterval(() => {
+      setFrame((f) => f + 1);
+    }, ms);
+    return () => {
+      if (intervalRef.current)
+        clearInterval(intervalRef.current);
+    };
+  }, [fps]);
+  return frame;
+}
+
+// packages/core/src/hooks/useInterval.js
+import { useEffect as useEffect3, useRef as useRef2 } from "react";
+function useInterval(callback, delay) {
+  const savedCallback = useRef2(callback);
+  useEffect3(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect3(() => {
+    if (delay === null)
+      return;
+    const id = setInterval(() => savedCallback.current(), delay);
+    return () => clearInterval(id);
+  }, [delay]);
+}
+
+// packages/core/src/hooks/useClipboard.js
+import { useCallback } from "react";
+function useClipboard() {
+  const write = useCallback((text) => {
+    process.stdout.write(osc.clipboardWrite(text));
+  }, []);
+  return { write };
+}
+
+// packages/core/src/hooks/useKeymap.js
+import { useEffect as useEffect4, useRef as useRef3 } from "react";
+function useKeymap(bindings, isActive = true) {
+  const bindingsRef = useRef3(bindings);
+  useEffect4(() => {
+    bindingsRef.current = bindings;
+  }, [bindings]);
+  useEffect4(() => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const b of bindings) {
+      const id = `${b.key ?? ""}:${b.ctrl ? "ctrl" : ""}:${b.shift ? "shift" : ""}:${b.meta ? "meta" : ""}`;
+      if (seen.has(id)) {
+        console.warn(`[useKeymap] Conflicting keybinding: ${id}`);
+      }
+      seen.add(id);
+    }
+  }, []);
+  useInput((input, key) => {
+    for (const binding of bindingsRef.current) {
+      const keyMatch = !binding.key || input === binding.key;
+      const ctrlMatch = binding.ctrl === void 0 || binding.ctrl === key.ctrl;
+      const shiftMatch = binding.shift === void 0 || binding.shift === key.shift;
+      const metaMatch = binding.meta === void 0 || binding.meta === key.meta;
+      if (keyMatch && ctrlMatch && shiftMatch && metaMatch) {
+        binding.action();
+      }
+    }
+  }, { isActive });
+}
+
+// packages/core/src/hooks/useMouse.js
+import { useEffect as useEffect5 } from "react";
+function useMouse(handler) {
+  const handlerRef = { current: handler };
+  useEffect5(() => {
+    handlerRef.current = handler;
+  });
+  useEffect5(() => {
+    if (!process.stdout.isTTY)
+      return;
+    process.stdout.write("\x1B[?1000h");
+    process.stdout.write("\x1B[?1002h");
+    process.stdout.write("\x1B[?1006h");
+    const rawHandler = (data) => {
+      const str = data.toString();
+      const match = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+      if (!match)
+        return;
+      const cb = parseInt(match[1], 10);
+      const x = parseInt(match[2], 10);
+      const y = parseInt(match[3], 10);
+      const released = match[4] === "m";
+      const ctrl = Boolean(cb & 16);
+      const meta = Boolean(cb & 8);
+      const shift = Boolean(cb & 4);
+      const buttonCode = cb & 3;
+      let button;
+      if (cb & 64) {
+        button = buttonCode === 0 ? "scrollUp" : "scrollDown";
+      } else {
+        button = ["left", "middle", "right"][buttonCode] ?? "left";
+      }
+      handlerRef.current({
+        type: released ? "release" : "press",
+        button,
+        x,
+        y,
+        ctrl,
+        shift,
+        meta
+      });
+    };
+    process.stdin.on("data", rawHandler);
+    return () => {
+      process.stdout.write("\x1B[?1000l");
+      process.stdout.write("\x1B[?1002l");
+      process.stdout.write("\x1B[?1006l");
+      process.stdin.off("data", rawHandler);
+    };
+  }, []);
+}
+
+// packages/core/src/hooks/useResize.js
+import { useState as useState3, useEffect as useEffect6 } from "react";
+function useResize(debounceMs = 50) {
+  const [size, setSize] = useState3({
+    columns: process.stdout.columns ?? 80,
+    rows: process.stdout.rows ?? 24
+  });
+  useEffect6(() => {
+    let timer;
+    const handler = () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        setSize({
+          columns: process.stdout.columns ?? 80,
+          rows: process.stdout.rows ?? 24
+        });
+      }, debounceMs);
+    };
+    process.stdout.on("resize", handler);
+    return () => {
+      clearTimeout(timer);
+      process.stdout.off("resize", handler);
+    };
+  }, [debounceMs]);
+  return size;
+}
+
+// packages/core/src/hooks/useAsync.js
+import { useState as useState4, useEffect as useEffect7, useCallback as useCallback2, useRef as useRef4 } from "react";
+function useAsync(asyncFn, deps = []) {
+  const [state, setState] = useState4({
+    status: "idle",
+    data: null,
+    error: null
+  });
+  const mountedRef = useRef4(true);
+  const execute = useCallback2(async () => {
+    setState({ status: "loading", data: null, error: null });
+    try {
+      const data = await asyncFn();
+      if (mountedRef.current) {
+        setState({ status: "success", data, error: null });
+      }
+    } catch (e) {
+      if (mountedRef.current) {
+        setState({ status: "error", data: null, error: e instanceof Error ? e : new Error(String(e)) });
+      }
+    }
+  }, deps);
+  useEffect7(() => {
+    mountedRef.current = true;
+    execute();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [execute]);
+  return { ...state, refetch: execute };
+}
+
+export {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  blink,
+  inverse,
+  hidden,
+  strikethrough,
+  fg,
+  bg,
+  fg256,
+  bg256,
+  fgRgb,
+  bgRgb,
+  parseHex,
+  fgHex,
+  bgHex,
+  cursor,
+  screen,
+  osc,
+  style,
+  stripAnsi,
+  visibleWidth,
+  detectCapabilities,
+  getCapabilities,
+  refreshCapabilities,
+  defaultTheme,
+  ThemeProvider,
+  useTheme,
+  useThemeUpdater,
+  createTheme,
+  StyleBuilder,
+  style2,
+  draculaTheme,
+  nordTheme,
+  useInput,
+  useFocus,
+  useFocusManager,
+  useTerminal,
+  useAnimation,
+  useInterval,
+  useClipboard,
+  useKeymap,
+  useMouse,
+  useResize,
+  useAsync
+};
+//# sourceMappingURL=chunk-ZZKFZA2U.js.map