@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/TuiApp-DfxOnXqi.js

@@ -0,0 +1,120 @@
+import EventEmitter from 'eventemitter3';
+import { Renderer, TerminalGuard } from './Renderer-zZ5O3vxc.js';
+
+const DEC_2026_ON = "\x1B[?2026h";
+const DEC_2026_OFF = "\x1B[?2026l";
+class TuiApp extends EventEmitter {
+  renderer;
+  terminal = null;
+  backBuffer;
+  width;
+  height;
+  isRunning = false;
+  stdoutBuffer = [];
+  stderrBuffer = [];
+  constructor() {
+    super();
+    this.width = process.stdout.columns || 80;
+    this.height = process.stdout.rows || 24;
+    this.renderer = new Renderer(this.width, this.height);
+    this.backBuffer = new Uint32Array(this.width * this.height * 2);
+  }
+  /** Enters raw mode + alternate screen. Does NOT start any render loop. */
+  start() {
+    if (this.isRunning) {
+      return;
+    }
+    this.terminal = new TerminalGuard(true);
+    this.isRunning = true;
+  }
+  /** Request a clean exit — restores terminal, stops input, exits the process. */
+  quit() {
+    this.emit("quit");
+  }
+  /** Exits raw mode + alternate screen, then flushes any buffered stdout/stderr. */
+  stop() {
+    this.isRunning = false;
+    this.terminal?.leave();
+    this.terminal = null;
+    if (this.stdoutBuffer.length > 0) {
+      process.stdout.write(this.stdoutBuffer.join(""));
+      this.stdoutBuffer = [];
+    }
+    if (this.stderrBuffer.length > 0) {
+      process.stderr.write(this.stderrBuffer.join(""));
+      this.stderrBuffer = [];
+    }
+  }
+  /**
+   * Buffer a write to stdout. While the alternate screen is active, writing
+   * directly would corrupt the TUI. Buffered output is flushed on stop().
+   */
+  writeStdout(text) {
+    if (this.isRunning) {
+      this.stdoutBuffer.push(text);
+    } else {
+      process.stdout.write(text);
+    }
+  }
+  /**
+   * Buffer a write to stderr. While the alternate screen is active, writing
+   * directly would corrupt the TUI. Buffered output is flushed on stop().
+   */
+  writeStderr(text) {
+    if (this.isRunning) {
+      this.stderrBuffer.push(text);
+    } else {
+      process.stderr.write(text);
+    }
+  }
+  /** Returns the shared Uint32Array back-buffer (width * height * 2 u32 cells). */
+  getBuffer() {
+    return this.backBuffer;
+  }
+  /** Returns current terminal dimensions. */
+  getSize() {
+    return { height: this.height, width: this.width };
+  }
+  /** Update terminal dimensions (called on SIGWINCH). */
+  resize(width, height) {
+    this.width = width;
+    this.height = height;
+    this.renderer = new Renderer(width, height);
+    this.backBuffer = new Uint32Array(width * height * 2);
+  }
+  /**
+   * Callbacks fired on every frame after React paints the buffer but before
+   * the Rust diff engine flushes to stdout. Use for direct buffer painting
+   * that needs to overlay React output (animated graphs, overlays, FPS counters).
+   * Multiple listeners are supported — they fire in registration order.
+   */
+  beforeFlushListeners = [];
+  onBeforeFlush(function_) {
+    this.beforeFlushListeners.push(function_);
+    return () => {
+      this.beforeFlushListeners = this.beforeFlushListeners.filter((f) => f !== function_);
+    };
+  }
+  /**
+   * Layout + paint synchronously. Called from the render loop on every dirty frame,
+   * and directly on resize for immediate response.
+   */
+  paintNow(calculateLayout, renderToBuffer) {
+    if (!this.isRunning) {
+      return;
+    }
+    calculateLayout(this.width, this.height);
+    renderToBuffer(this.backBuffer, this.width, this.height);
+    for (const function_ of this.beforeFlushListeners) {
+      function_(this.backBuffer, this.width, this.height);
+    }
+    this.renderer.writeRaw(DEC_2026_ON);
+    try {
+      this.renderer.render(this.backBuffer);
+    } finally {
+      this.renderer.writeRaw(DEC_2026_OFF);
+    }
+  }
+}
+
+export { TuiApp };

package/dist/packem_shared/TuiContext-CqEjMyXd.js

@@ -0,0 +1,415 @@
+import { createContext, useContext, useState, useCallback, useEffect, useMemo, useRef } from 'react';
+
+const TuiContext = createContext(null);
+const useInput = (handler) => {
+  const context = useContext(TuiContext);
+  if (!context) {
+    throw new Error("useInput must be used within a TUI App environment");
+  }
+  const handlerRef = useRef(handler);
+  useEffect(() => {
+    handlerRef.current = handler;
+  });
+  useEffect(() => {
+    const key = (overrides) => {
+      return {
+        backspace: false,
+        ctrl: false,
+        delete: false,
+        downArrow: false,
+        end: false,
+        escape: false,
+        home: false,
+        leftArrow: false,
+        meta: false,
+        pageDown: false,
+        pageUp: false,
+        return: false,
+        rightArrow: false,
+        shift: false,
+        tab: false,
+        upArrow: false,
+        ...overrides
+      };
+    };
+    const handleKeydown = (keyName) => {
+      switch (keyName) {
+        case "backspace": {
+          return handlerRef.current("", key({ backspace: true }));
+        }
+        case "delete": {
+          return handlerRef.current("", key({ delete: true }));
+        }
+        case "down": {
+          return handlerRef.current("", key({ downArrow: true }));
+        }
+        case "end": {
+          return handlerRef.current("", key({ end: true }));
+        }
+        case "enter": {
+          return handlerRef.current("", key({ return: true }));
+        }
+        case "escape": {
+          return handlerRef.current("", key({ escape: true }));
+        }
+        case "home": {
+          return handlerRef.current("", key({ home: true }));
+        }
+        case "left": {
+          return handlerRef.current("", key({ leftArrow: true }));
+        }
+        case "pageDown": {
+          return handlerRef.current("", key({ pageDown: true }));
+        }
+        case "pageUp": {
+          return handlerRef.current("", key({ pageUp: true }));
+        }
+        case "right": {
+          return handlerRef.current("", key({ rightArrow: true }));
+        }
+        case "shift-tab": {
+          return handlerRef.current("", key({ shift: true, tab: true }));
+        }
+        case "tab": {
+          return handlerRef.current("", key({ tab: true }));
+        }
+        case "up": {
+          return handlerRef.current("", key({ upArrow: true }));
+        }
+      }
+    };
+    const handleCtrl = (letter) => {
+      handlerRef.current(letter, key({ ctrl: true }));
+    };
+    const handleMeta = (letter) => {
+      handlerRef.current(letter, key({ meta: true }));
+    };
+    const handleData = (data, flags) => {
+      if (data.startsWith("\x1B")) {
+        return;
+      }
+      if (data === "\r" || data === "\n") {
+        return;
+      }
+      handlerRef.current(
+        data,
+        key({
+          ctrl: flags?.ctrl ?? false,
+          meta: flags?.meta ?? false
+        })
+      );
+    };
+    context.input.on("keydown", handleKeydown);
+    context.input.on("ctrl", handleCtrl);
+    context.input.on("meta", handleMeta);
+    context.input.on("data", handleData);
+    return () => {
+      context.input.off("keydown", handleKeydown);
+      context.input.off("ctrl", handleCtrl);
+      context.input.off("meta", handleMeta);
+      context.input.off("data", handleData);
+    };
+  }, [context]);
+};
+const usePaste = (handler, options = {}) => {
+  const context = useContext(TuiContext);
+  if (!context) {
+    throw new Error("usePaste must be used within a TUI App environment");
+  }
+  const { isActive = true } = options;
+  const handlerRef = useRef(handler);
+  useEffect(() => {
+    handlerRef.current = handler;
+  });
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    const onPaste = (text) => {
+      handlerRef.current(text);
+    };
+    context.input.on("paste", onPaste);
+    return () => {
+      context.input.off("paste", onPaste);
+    };
+  }, [context, isActive]);
+};
+const useTuiContext = () => {
+  const context = useContext(TuiContext);
+  if (!context)
+    throw new Error("useTuiContext must be used within a TUI App environment");
+  return context;
+};
+const useApp = () => {
+  const context = useContext(TuiContext);
+  if (!context) {
+    throw new Error("useApp must be used within a TUI App environment");
+  }
+  return {
+    // Ink-compatible: const { exit } = useApp()
+    exit: () => context.app.quit(),
+    // internal: direct app access
+    quit: () => context.app.quit()
+  };
+};
+const useWindowSize = () => {
+  const context = useContext(TuiContext);
+  if (!context) {
+    throw new Error("useWindowSize must be used within a TUI App environment");
+  }
+  const [size, setSize] = useState(() => context.app.getSize());
+  useEffect(() => {
+    const onResize = () => setSize(context.app.getSize());
+    context.app.on("resize", onResize);
+    return () => {
+      context.app.off("resize", onResize);
+    };
+  }, [context]);
+  return { columns: size.width, rows: size.height };
+};
+const toRawNewlines = (text) => text.replaceAll(/\r?\n/g, "\r\n");
+const useStdout = () => {
+  const context = useContext(TuiContext);
+  return {
+    stdout: process.stdout,
+    write: (text) => {
+      context ? context.writeStdout(text) : process.stdout.write(toRawNewlines(text));
+    }
+  };
+};
+const useStderr = () => {
+  const context = useContext(TuiContext);
+  return {
+    stderr: process.stderr,
+    write: (text) => {
+      context ? context.writeStderr(text) : process.stderr.write(toRawNewlines(text));
+    }
+  };
+};
+const useStdin = () => {
+  const isRawModeSupported = !!process.stdin.setRawMode;
+  return {
+    isRawModeSupported,
+    setRawMode: (value) => {
+      if (isRawModeSupported) {
+        process.stdin.setRawMode(value);
+      }
+    },
+    stdin: process.stdin
+  };
+};
+const measureElement = (node) => {
+  if (!node || !node.yogaNode)
+    return { height: 0, width: 0 };
+  return {
+    height: node.yogaNode.getComputedHeight() ?? 0,
+    width: node.yogaNode.getComputedWidth() ?? 0
+  };
+};
+const emptyMetrics = { height: 0, left: 0, top: 0, width: 0 };
+const useBoxMetrics = (ref) => {
+  const context = useContext(TuiContext);
+  const [metrics, setMetrics] = useState(emptyMetrics);
+  const [hasMeasured, setHasMeasured] = useState(false);
+  const updateMetrics = useCallback(() => {
+    if (!ref.current?.yogaNode) {
+      setHasMeasured(false);
+      return;
+    }
+    const layout = ref.current.getLayout();
+    setMetrics((previous) => {
+      if (previous.width === layout.width && previous.height === layout.height && previous.left === layout.left && previous.top === layout.top) {
+        return previous;
+      }
+      return { height: layout.height, left: layout.left, top: layout.top, width: layout.width };
+    });
+    setHasMeasured(true);
+  }, [ref]);
+  useEffect(updateMetrics);
+  useEffect(() => {
+    if (!context?.app) {
+      return;
+    }
+    context.app.on("resize", updateMetrics);
+    return () => {
+      context.app.off("resize", updateMetrics);
+    };
+  }, [context, updateMetrics]);
+  return useMemo(() => {
+    return { ...metrics, hasMeasured };
+  }, [metrics, hasMeasured]);
+};
+const useIsScreenReaderEnabled = () => false;
+const useCursor = () => {
+  return {
+    setCursorPosition: (_position) => {
+    }
+  };
+};
+const useScrollable = ({ contentHeight, viewportHeight }) => {
+  const [offset, setOffset] = useState(0);
+  const max = Math.max(0, contentHeight - viewportHeight);
+  const clamp = useCallback((n) => Math.max(0, Math.min(n, max)), [max]);
+  useEffect(() => {
+    setOffset((o) => clamp(o));
+  }, [max, clamp]);
+  return useMemo(() => {
+    return {
+      atBottom: clamp(offset) >= max,
+      atTop: clamp(offset) <= 0,
+      offset: clamp(offset),
+      scrollBy: (n) => setOffset((o) => clamp(o + n)),
+      scrollDown: () => setOffset((o) => clamp(o + 1)),
+      scrollToBottom: () => setOffset(max),
+      scrollToTop: () => setOffset(0),
+      scrollUp: () => setOffset((o) => clamp(o - 1))
+    };
+  }, [offset, max, clamp]);
+};
+const useMouse = (handler) => {
+  const context = useContext(TuiContext);
+  if (!context)
+    throw new Error("useMouse must be used within a TUI App environment");
+  const handlerRef = useRef(handler);
+  useEffect(() => {
+    handlerRef.current = handler;
+  });
+  useEffect(() => {
+    const onMouse = (event) => handlerRef.current(event);
+    context.input.on("mouse", onMouse);
+    return () => {
+      context.input.off("mouse", onMouse);
+    };
+  }, [context]);
+};
+const useTextInput = ({ initialValue = "", isActive = true, onChange, onSubmit } = {}) => {
+  const [value, setValueRaw] = useState(initialValue);
+  const [cursor, setCursor] = useState(initialValue.length);
+  const valueRef = useRef(value);
+  const cursorRef = useRef(cursor);
+  useEffect(() => {
+    valueRef.current = value;
+  });
+  useEffect(() => {
+    cursorRef.current = cursor;
+  });
+  const onChangeRef = useRef(onChange);
+  useEffect(() => {
+    onChangeRef.current = onChange;
+  });
+  const onSubmitRef = useRef(onSubmit);
+  useEffect(() => {
+    onSubmitRef.current = onSubmit;
+  });
+  const setValue = useCallback((newValue) => {
+    setValueRaw(newValue);
+    setCursor(newValue.length);
+  }, []);
+  const clear = useCallback(() => {
+    setValueRaw("");
+    setCursor(0);
+    onChangeRef.current?.("");
+  }, []);
+  useInput((input, key) => {
+    if (!isActive) {
+      return;
+    }
+    const { current } = cursorRef;
+    const value_ = valueRef.current;
+    if (key.return) {
+      onSubmitRef.current?.(value_);
+      return;
+    }
+    if (key.escape) {
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor(Math.max(0, current - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor(Math.min(value_.length, current + 1));
+      return;
+    }
+    if (key.home || key.ctrl && input === "a") {
+      setCursor(0);
+      return;
+    }
+    if (key.end || key.ctrl && input === "e") {
+      setCursor(value_.length);
+      return;
+    }
+    if (key.backspace) {
+      if (current === 0) {
+        return;
+      }
+      const next = value_.slice(0, current - 1) + value_.slice(current);
+      setValueRaw(next);
+      setCursor(current - 1);
+      onChangeRef.current?.(next);
+      return;
+    }
+    if (key.delete) {
+      if (current >= value_.length) {
+        return;
+      }
+      const next = value_.slice(0, current) + value_.slice(current + 1);
+      setValueRaw(next);
+      onChangeRef.current?.(next);
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      const next = value_.slice(current);
+      setValueRaw(next);
+      setCursor(0);
+      onChangeRef.current?.(next);
+      return;
+    }
+    if (key.ctrl && input === "k") {
+      const next = value_.slice(0, current);
+      setValueRaw(next);
+      onChangeRef.current?.(next);
+      return;
+    }
+    if (key.ctrl && input === "w") {
+      const before = value_.slice(0, current);
+      const trimmed = before.replace(/\S+\s*$/, "");
+      const next = trimmed + value_.slice(current);
+      setValueRaw(next);
+      setCursor(trimmed.length);
+      onChangeRef.current?.(next);
+      return;
+    }
+    if (key.ctrl || key.meta) {
+      return;
+    }
+    if (input && input.length > 0) {
+      const next = value_.slice(0, current) + input + value_.slice(current);
+      setValueRaw(next);
+      setCursor(current + input.length);
+      onChangeRef.current?.(next);
+    }
+  });
+  const context = useContext(TuiContext);
+  useEffect(() => {
+    if (!context || !isActive) {
+      return;
+    }
+    const onPaste = (text) => {
+      const safe = text.replaceAll(/[\u0000-\u0008\u000B-\u001F\u007F]/g, "").replaceAll(/\r\n?/g, " ");
+      const { current } = cursorRef;
+      const value_ = valueRef.current;
+      const next = value_.slice(0, current) + safe + value_.slice(current);
+      setValueRaw(next);
+      setCursor(current + safe.length);
+      onChangeRef.current?.(next);
+    };
+    context.input.on("paste", onPaste);
+    return () => {
+      context.input.off("paste", onPaste);
+    };
+  }, [context, isActive]);
+  return { clear, cursor, setValue, value };
+};
+
+export { TuiContext, measureElement, useApp, useBoxMetrics, useCursor, useInput, useIsScreenReaderEnabled, useMouse, usePaste, useScrollable, useStderr, useStdin, useStdout, useTextInput, useTuiContext, useWindowSize };

package/dist/packem_shared/UnorderedList-DhnadWjX.js

@@ -0,0 +1,33 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import Box from './Box-D_pSJ9Jp.js';
+import Text from './Text-DvAUdZcK.js';
+
+const DEFAULT_MARKERS = ["─", "◦", "▪"];
+const resolveMarkers = (marker) => {
+  if (typeof marker === "string") {
+    return [marker];
+  }
+  if (Array.isArray(marker)) {
+    return marker;
+  }
+  return DEFAULT_MARKERS;
+};
+const renderList = (items, markers, depth) => {
+  const resolvedMarker = markers[depth % markers.length] ?? "─";
+  return jsx(Box, { flexDirection: "column", children: items.map((item, index) => (
+    // eslint-disable-next-line react-x/no-array-index-key -- list entries have no unique key
+    jsxs(Box, { gap: 1, children: [
+      jsx(Text, { dimColor: true, children: resolvedMarker }),
+      jsxs(Box, { flexDirection: "column", children: [
+        jsx(Text, { children: item.label }),
+        item.children ? renderList(item.children, markers, depth + 1) : void 0
+      ] })
+    ] }, index)
+  )) });
+};
+function UnorderedList({ items, marker }) {
+  const markers = resolveMarkers(marker);
+  return renderList(items, markers, 0);
+}
+
+export { UnorderedList as default };

package/dist/packem_shared/ansi-parser-0BdVTKho.js

@@ -0,0 +1,41 @@
+const ANSI_CODES = {
+  // SET_VT200_MOUSE - Terminal will send event on button pressed with mouse position
+  mouseButton: { off: "\x1B[?1000l", on: "\x1B[?1000h" },
+  // SET_ANY_EVENT_MOUSE - Terminal will send event on button pressed and motion
+  mouseMotion: { off: "\x1B[?1003l", on: "\x1B[?1003h" },
+  // SET_URXVT_EXT_MODE_MOUSE
+  mouseMotionOthers: { off: "\x1B[?1015l", on: "\x1B[?1015h" },
+  // SET_SGR_EXT_MODE_MOUSE - Another mouse protocol that extends coordinate mapping (without it, supports only 223 rows and columns)
+  mouseSGR: { off: "\x1B[?1006l", on: "\x1B[?1006h" }};
+const SGR_MOUSE_PATTERN = /\[<(\d+);(\d+);(\d+)(M)$/i;
+
+const CLICK_BUTTONS = { 0: "left", 1: "middle", 2: "right" };
+const DRAG_BUTTONS = { 32: "left", 33: "middle", 34: "right" };
+const parseSgrMouse = (input) => {
+  const match = SGR_MOUSE_PATTERN.exec(input);
+  if (!match) {
+    return void 0;
+  }
+  const rawButton = Number(match[1]);
+  const x = Number(match[2]);
+  const y = Number(match[3]);
+  const isRelease = match[4] === "m";
+  const base = rawButton & -29;
+  if (base === 64 || base === 65) {
+    return { direction: base === 64 ? "scrollup" : "scrolldown", type: "scroll", x, y };
+  }
+  if (base === 35) {
+    return { type: "move", x, y };
+  }
+  const dragButton = DRAG_BUTTONS[base];
+  if (dragButton) {
+    return { action: isRelease ? "release" : "press", button: dragButton, type: "drag", x, y };
+  }
+  const clickButton = CLICK_BUTTONS[base];
+  if (clickButton) {
+    return { action: isRelease ? "release" : "press", button: clickButton, type: "click", x, y };
+  }
+  return void 0;
+};
+
+export { ANSI_CODES as A, parseSgrMouse as p };