@tuicomponents/core 0.1.1

package/dist/index.cjs

@@ -0,0 +1,629 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseTuiComponent: () => BaseTuiComponent,
+  ComponentRegistry: () => ComponentRegistry,
+  DEFAULT_ANCHOR: () => DEFAULT_ANCHOR,
+  DEFAULT_TERMINAL_HEIGHT: () => DEFAULT_TERMINAL_HEIGHT,
+  DEFAULT_TERMINAL_WIDTH: () => DEFAULT_TERMINAL_WIDTH,
+  anchorLine: () => anchorLine,
+  applyMarkdownStyle: () => applyMarkdownStyle,
+  createRenderContext: () => createRenderContext,
+  createStyleFunctions: () => createStyleFunctions,
+  createThemeSync: () => createThemeSync,
+  defaultTheme: () => defaultTheme,
+  detectColorLevel: () => detectColorLevel,
+  detectEnvironment: () => detectEnvironment,
+  detectTheme: () => detectTheme,
+  getMarkdownRenderedWidth: () => getMarkdownRenderedWidth,
+  getProcessTree: () => getProcessTree,
+  getStringWidth: () => getStringWidth,
+  getTerminalSize: () => getTerminalSize,
+  getTerminalWidth: () => getTerminalWidth,
+  inlineCode: () => inlineCode,
+  isRunningInAIAssistant: () => isRunningInAIAssistant,
+  isTTY: () => isTTY,
+  joinAnchoredLines: () => joinAnchoredLines,
+  measureLines: () => measureLines,
+  padToWidth: () => padToWidth,
+  registry: () => registry,
+  stripMarkdownFormatting: () => stripMarkdownFormatting,
+  truncateToWidth: () => truncateToWidth,
+  wrapText: () => wrapText,
+  wrapTextWithInfo: () => wrapTextWithInfo
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/component.ts
+var import_zod_to_json_schema = require("zod-to-json-schema");
+var BaseTuiComponent = class {
+  getJsonSchema() {
+    return (0, import_zod_to_json_schema.zodToJsonSchema)(this.schema, {
+      name: this.metadata.name,
+      $refStrategy: "none"
+    });
+  }
+};
+
+// src/registry.ts
+var ComponentRegistry = class {
+  components = /* @__PURE__ */ new Map();
+  /**
+   * Register a component by invoking its factory function.
+   * @param factory - Factory function that creates the component
+   * @returns The created component instance
+   */
+  register(factory) {
+    const component = factory();
+    const name = component.metadata.name;
+    if (this.components.has(name)) {
+      throw new Error(`Component "${name}" is already registered`);
+    }
+    this.components.set(name, component);
+    return component;
+  }
+  /**
+   * Get a component by name.
+   * @param name - Component name
+   * @returns The component or undefined if not found
+   */
+  get(name) {
+    return this.components.get(name);
+  }
+  /**
+   * Check if a component is registered.
+   * @param name - Component name
+   */
+  has(name) {
+    return this.components.has(name);
+  }
+  /**
+   * List all registered components.
+   * @returns Array of component info objects
+   */
+  list() {
+    return Array.from(this.components.values()).map((c) => ({
+      name: c.metadata.name,
+      description: c.metadata.description,
+      version: c.metadata.version
+    }));
+  }
+  /**
+   * Get all registered component names.
+   */
+  names() {
+    return Array.from(this.components.keys());
+  }
+  /**
+   * Clear all registered components.
+   * Primarily useful for testing.
+   */
+  clear() {
+    this.components.clear();
+  }
+};
+var registry = new ComponentRegistry();
+
+// src/width.ts
+var import_string_width = __toESM(require("string-width"), 1);
+function getStringWidth(str) {
+  return (0, import_string_width.default)(str);
+}
+function padToWidth(str, targetWidth, options = {}) {
+  const { padChar = " ", align = "left" } = options;
+  const currentWidth = getStringWidth(str);
+  if (currentWidth >= targetWidth) {
+    return str;
+  }
+  const padCharWidth = getStringWidth(padChar);
+  if (padCharWidth === 0) {
+    return str;
+  }
+  const paddingNeeded = targetWidth - currentWidth;
+  const padCount = Math.floor(paddingNeeded / padCharWidth);
+  const padding = padChar.repeat(padCount);
+  switch (align) {
+    case "right":
+      return padding + str;
+    case "center": {
+      const leftPadCount = Math.floor(padCount / 2);
+      const rightPadCount = padCount - leftPadCount;
+      return padChar.repeat(leftPadCount) + str + padChar.repeat(rightPadCount);
+    }
+    case "left":
+    default:
+      return str + padding;
+  }
+}
+function truncateToWidth(str, targetWidth, options = {}) {
+  const { ellipsis = "\u2026", position = "end" } = options;
+  const currentWidth = getStringWidth(str);
+  if (currentWidth <= targetWidth) {
+    return str;
+  }
+  const ellipsisWidth = getStringWidth(ellipsis);
+  if (ellipsisWidth >= targetWidth) {
+    return truncateChars(str, targetWidth);
+  }
+  const availableWidth = targetWidth - ellipsisWidth;
+  if (position === "middle") {
+    const leftWidth = Math.ceil(availableWidth / 2);
+    const rightWidth = Math.floor(availableWidth / 2);
+    const leftPart = truncateChars(str, leftWidth);
+    const rightPart = truncateCharsFromEnd(str, rightWidth);
+    return leftPart + ellipsis + rightPart;
+  }
+  return truncateChars(str, availableWidth) + ellipsis;
+}
+function truncateChars(str, targetWidth) {
+  let result = "";
+  let width = 0;
+  for (const char of str) {
+    const charWidth = getStringWidth(char);
+    if (width + charWidth > targetWidth) {
+      break;
+    }
+    result += char;
+    width += charWidth;
+  }
+  return result;
+}
+function truncateCharsFromEnd(str, targetWidth) {
+  const collectedChars = [];
+  for (const char of str) {
+    collectedChars.push(char);
+  }
+  let result = "";
+  let width = 0;
+  for (let i = collectedChars.length - 1; i >= 0; i--) {
+    const char = collectedChars[i];
+    if (char === void 0) continue;
+    const charWidth = getStringWidth(char);
+    if (width + charWidth > targetWidth) {
+      break;
+    }
+    result = char + result;
+    width += charWidth;
+  }
+  return result;
+}
+function measureLines(str) {
+  const lines = str.split("\n");
+  let maxWidth = 0;
+  for (const line of lines) {
+    const lineWidth = getStringWidth(line);
+    if (lineWidth > maxWidth) {
+      maxWidth = lineWidth;
+    }
+  }
+  return {
+    lines,
+    maxWidth,
+    lineCount: lines.length
+  };
+}
+
+// src/terminal.ts
+var import_terminal_size = __toESM(require("terminal-size"), 1);
+
+// src/detection.ts
+var import_node_child_process = require("child_process");
+var AI_ASSISTANT_PATTERNS = [
+  { pattern: /claude-code/i, name: "claude-code" },
+  { pattern: /claude$/i, name: "claude" },
+  { pattern: /cursor/i, name: "cursor" },
+  { pattern: /copilot/i, name: "copilot" },
+  { pattern: /windsurf/i, name: "windsurf" },
+  { pattern: /cody/i, name: "cody" },
+  { pattern: /aider/i, name: "aider" },
+  { pattern: /continue/i, name: "continue" }
+  // continue.dev
+];
+function getProcessTree() {
+  if (process.platform === "win32") {
+    return [];
+  }
+  const ancestors = [];
+  let pid = process.ppid;
+  for (let i = 0; i < 20 && pid > 1; i++) {
+    try {
+      const output = (0, import_node_child_process.execSync)(`ps -p ${String(pid)} -o ppid=,comm=`, {
+        encoding: "utf-8",
+        timeout: 1e3
+      }).trim();
+      const match = /^\s*(\d+)\s+(.+)$/.exec(output);
+      if (!match?.[1] || !match[2]) break;
+      const ppid = parseInt(match[1], 10);
+      const command = match[2];
+      ancestors.push({ pid, command });
+      pid = ppid;
+    } catch {
+      break;
+    }
+  }
+  return ancestors;
+}
+function findAIAssistantInProcessTree(processTree) {
+  for (const ancestor of processTree) {
+    for (const { pattern, name } of AI_ASSISTANT_PATTERNS) {
+      if (pattern.test(ancestor.command)) {
+        return name;
+      }
+    }
+  }
+  return void 0;
+}
+function detectEnvironment() {
+  const processTree = getProcessTree();
+  let aiScore = 0;
+  let terminalScore = 0;
+  let detectedAssistant;
+  detectedAssistant = findAIAssistantInProcessTree(processTree);
+  if (detectedAssistant) {
+    aiScore += 10;
+  }
+  const stdoutIsTTY = process.stdout.isTTY;
+  const stdinIsTTY = process.stdin.isTTY;
+  if (!stdoutIsTTY) {
+    aiScore += 2;
+  } else {
+    terminalScore += 2;
+  }
+  if (!stdinIsTTY) {
+    aiScore += 1;
+  }
+  if (process.env["CLAUDE_CODE"]) {
+    aiScore += 5;
+    detectedAssistant = detectedAssistant ?? "claude-code";
+  }
+  if (process.env["CURSOR_TRACE_ID"] || process.env["CURSOR_SESSION"]) {
+    aiScore += 3;
+    detectedAssistant = detectedAssistant ?? "cursor";
+  }
+  if (process.env["VSCODE_PID"] || process.env["VSCODE_IPC_HOOK"]) {
+    aiScore += 1;
+  }
+  const termProgram = process.env["TERM_PROGRAM"];
+  if (termProgram) {
+    const knownTerminals = [
+      "iTerm.app",
+      "Apple_Terminal",
+      "Hyper",
+      "Alacritty",
+      "kitty",
+      "WezTerm",
+      "Ghostty"
+    ];
+    if (knownTerminals.some((t) => termProgram.includes(t))) {
+      terminalScore += 2;
+    }
+  }
+  const term = process.env["TERM"];
+  if (term && term !== "dumb") {
+    terminalScore += 1;
+    if (term.includes("256color") || term.includes("truecolor")) {
+      terminalScore += 1;
+    }
+  } else if (term === "dumb" || !term) {
+    aiScore += 1;
+  }
+  if (process.env["ITERM_SESSION_ID"]) {
+    terminalScore += 2;
+  }
+  if (process.env["KITTY_WINDOW_ID"]) {
+    terminalScore += 2;
+  }
+  if (process.env["CI"] || process.env["GITHUB_ACTIONS"]) {
+    aiScore += 2;
+  }
+  const isAIAssistant = aiScore > terminalScore;
+  let confidence;
+  const scoreDiff = Math.abs(aiScore - terminalScore);
+  if (scoreDiff >= 4) {
+    confidence = "high";
+  } else if (scoreDiff >= 2) {
+    confidence = "medium";
+  } else {
+    confidence = "low";
+  }
+  const result = {
+    isAIAssistant,
+    confidence,
+    processTree
+  };
+  if (detectedAssistant !== void 0) {
+    result.detectedAssistant = detectedAssistant;
+  }
+  return result;
+}
+function isRunningInAIAssistant() {
+  return detectEnvironment().isAIAssistant;
+}
+
+// src/markdown.ts
+var DEFAULT_ANCHOR = "\u2502";
+function inlineCode(text) {
+  return ` \`${text}\``;
+}
+function anchorLine(content, anchor = DEFAULT_ANCHOR) {
+  return `${anchor}${content}`;
+}
+function applyMarkdownStyle(text, style) {
+  if (style === "secondary") {
+    return inlineCode(text);
+  }
+  return text;
+}
+function joinAnchoredLines(lines, anchor = DEFAULT_ANCHOR) {
+  return lines.map((line) => anchorLine(line, anchor)).join("\n");
+}
+function stripMarkdownFormatting(str) {
+  let result = str;
+  result = result.replace(/`([^`]+)`/g, "$1");
+  result = result.replace(/\*\*([^*]+)\*\*/g, "$1");
+  result = result.replace(/__([^_]+)__/g, "$1");
+  result = result.replace(
+    /(?<![*\w])\*([^*\s][^*]*[^*\s]|[^*\s])\*(?![*\w])/g,
+    "$1"
+  );
+  result = result.replace(
+    /(?<![_\w])_([^_\s][^_]*[^_\s]|[^_\s])_(?![_\w])/g,
+    "$1"
+  );
+  return result;
+}
+function getMarkdownRenderedWidth(str) {
+  return getStringWidth(stripMarkdownFormatting(str));
+}
+
+// src/styling.ts
+var markdownStyleFunctions = {
+  primary: (text) => text,
+  secondary: (text) => text === "" ? "" : inlineCode(text),
+  header: (text) => text === "" ? "" : `**${text}**`,
+  border: (text) => text,
+  success: (text) => text === "" ? "" : inlineCode(text),
+  warning: (text) => text === "" ? "" : inlineCode(text),
+  error: (text) => text === "" ? "" : inlineCode(text),
+  info: (text) => text === "" ? "" : inlineCode(text)
+};
+function createPassthroughStyleFunctions() {
+  const passthrough = (text) => text;
+  return {
+    primary: passthrough,
+    secondary: passthrough,
+    header: passthrough,
+    border: passthrough,
+    success: passthrough,
+    warning: passthrough,
+    error: passthrough,
+    info: passthrough
+  };
+}
+function createThemedStyleFunctions(theme) {
+  return {
+    primary: (text) => theme.semantic.primary(text),
+    secondary: (text) => theme.semantic.secondary(text),
+    header: (text) => theme.semantic.header(text),
+    border: (text) => theme.semantic.border(text),
+    success: (text) => theme.semantic.success(text),
+    warning: (text) => theme.semantic.warning(text),
+    error: (text) => theme.semantic.error(text),
+    info: (text) => theme.semantic.info(text)
+  };
+}
+function createStyleFunctions(renderMode, theme) {
+  if (renderMode === "markdown") {
+    return markdownStyleFunctions;
+  }
+  if (theme) {
+    return createThemedStyleFunctions(theme);
+  }
+  return createPassthroughStyleFunctions();
+}
+
+// src/theme.ts
+var import_chromaterm = require("chromaterm");
+function createSemanticColors(theme) {
+  return {
+    primary: theme.foreground,
+    secondary: theme.muted,
+    border: theme.muted,
+    header: theme.brightWhite,
+    success: theme.success,
+    warning: theme.warning,
+    error: theme.error,
+    info: theme.info,
+    added: theme.green,
+    removed: theme.red,
+    modified: theme.yellow
+  };
+}
+function createThemeSync() {
+  const chromaterm = (0, import_chromaterm.createT1Theme)();
+  return {
+    chromaterm,
+    semantic: createSemanticColors(chromaterm)
+  };
+}
+async function detectTheme(options) {
+  const chromaterm = await (0, import_chromaterm.detectTheme)(options);
+  return {
+    chromaterm,
+    semantic: createSemanticColors(chromaterm)
+  };
+}
+var defaultTheme = createThemeSync();
+
+// src/terminal.ts
+var DEFAULT_TERMINAL_WIDTH = 80;
+var DEFAULT_TERMINAL_HEIGHT = 24;
+function getTerminalSize() {
+  const size = (0, import_terminal_size.default)();
+  return {
+    columns: size.columns || DEFAULT_TERMINAL_WIDTH,
+    rows: size.rows || DEFAULT_TERMINAL_HEIGHT
+  };
+}
+function getTerminalWidth() {
+  return getTerminalSize().columns;
+}
+function isTTY() {
+  const stdout = process.stdout;
+  return stdout.isTTY === true;
+}
+function detectColorLevel() {
+  if (process.env["NO_COLOR"] !== void 0) {
+    return 0;
+  }
+  const forceColor = process.env["FORCE_COLOR"];
+  if (forceColor !== void 0) {
+    if (forceColor === "0" || forceColor === "false") {
+      return 0;
+    }
+    if (forceColor === "1" || forceColor === "true" || forceColor === "") {
+      return 1;
+    }
+    if (forceColor === "2") {
+      return 2;
+    }
+    if (forceColor === "3") {
+      return 3;
+    }
+  }
+  if (!isTTY()) {
+    return 0;
+  }
+  const colorTerm = process.env["COLORTERM"];
+  if (colorTerm === "truecolor" || colorTerm === "24bit") {
+    return 3;
+  }
+  const term = process.env["TERM"] ?? "";
+  if (term.includes("256color") || term.includes("256")) {
+    return 2;
+  }
+  if (term.includes("color") || term.includes("ansi") || term === "xterm" || term === "linux") {
+    return 1;
+  }
+  return 1;
+}
+function determineRenderMode(options) {
+  if (options.renderMode !== void 0) {
+    return options.renderMode;
+  }
+  if (options.autoDetectMode === false) {
+    return "ansi";
+  }
+  if (isRunningInAIAssistant()) {
+    return "markdown";
+  }
+  return "ansi";
+}
+function createRenderContext(options = {}) {
+  const renderMode = determineRenderMode(options);
+  const colorLevel = options.noColor ? 0 : detectColorLevel();
+  const tty = isTTY();
+  const theme = colorLevel > 0 && renderMode === "ansi" ? options.theme ?? defaultTheme : void 0;
+  const context = {
+    width: options.width ?? getTerminalWidth(),
+    isTTY: tty,
+    colorLevel,
+    renderMode,
+    style: createStyleFunctions(renderMode, theme)
+  };
+  if (theme) {
+    context.theme = theme;
+  }
+  return context;
+}
+
+// src/wrap.ts
+var import_wrap_ansi = __toESM(require("wrap-ansi"), 1);
+function wrapText(text, width, options = {}) {
+  const { hard = false, trim = true, wordWrap = true } = options;
+  return (0, import_wrap_ansi.default)(text, width, {
+    hard,
+    trim,
+    wordWrap
+  });
+}
+function wrapTextWithInfo(text, width, options = {}) {
+  const wrapped = wrapText(text, width, options);
+  const lines = wrapped.split("\n");
+  let maxWidth = 0;
+  for (const line of lines) {
+    const lineWidth = getStringWidth(line);
+    if (lineWidth > maxWidth) {
+      maxWidth = lineWidth;
+    }
+  }
+  return {
+    text: wrapped,
+    lines,
+    lineCount: lines.length,
+    maxWidth
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseTuiComponent,
+  ComponentRegistry,
+  DEFAULT_ANCHOR,
+  DEFAULT_TERMINAL_HEIGHT,
+  DEFAULT_TERMINAL_WIDTH,
+  anchorLine,
+  applyMarkdownStyle,
+  createRenderContext,
+  createStyleFunctions,
+  createThemeSync,
+  defaultTheme,
+  detectColorLevel,
+  detectEnvironment,
+  detectTheme,
+  getMarkdownRenderedWidth,
+  getProcessTree,
+  getStringWidth,
+  getTerminalSize,
+  getTerminalWidth,
+  inlineCode,
+  isRunningInAIAssistant,
+  isTTY,
+  joinAnchoredLines,
+  measureLines,
+  padToWidth,
+  registry,
+  stripMarkdownFormatting,
+  truncateToWidth,
+  wrapText,
+  wrapTextWithInfo
+});
+//# sourceMappingURL=index.cjs.map