@outfitter/tui 0.2.0

package/dist/shared/@outfitter/tui-sv2xmh3w.d.ts

@@ -0,0 +1,26 @@
+import { VisualTheme } from "./tui-8j1gbehy";
+/**
+* Minimal visual theme.
+*
+* Features:
+* - ASCII-only borders (+, -, |)
+* - ASCII-safe list bullets and checkboxes
+* - Line spinner (ASCII-compatible)
+* - No unicode characters anywhere
+*
+* Use this theme when targeting terminals without unicode support
+* or when running in CI/log environments.
+*
+* @example
+* ```typescript
+* import { minimalTheme } from "@outfitter/tui/theme/presets";
+*
+* // Use ASCII-safe styling
+* const box = renderBox("Hello", { border: minimalTheme.border });
+* // +-------+
+* // | Hello |
+* // +-------+
+* ```
+*/
+declare const minimalTheme: VisualTheme;
+export { minimalTheme };

package/dist/shared/@outfitter/tui-t1a9xgbd.js

@@ -0,0 +1,111 @@
+// @bun
+import {
+  getBorderCharacters,
+  init_borders
+} from "./tui-2pwhzg55.js";
+
+// packages/tui/src/render/table.ts
+init_borders();
+import { getStringWidth, padText, truncateText } from "@outfitter/cli/text";
+function renderTable(data, options) {
+  if (data.length === 0) {
+    return "";
+  }
+  const allKeys = new Set;
+  for (const row of data) {
+    for (const key of Object.keys(row)) {
+      allKeys.add(key);
+    }
+  }
+  const keys = Array.from(allKeys);
+  const headers = options?.headers ?? {};
+  const getHeader = (key) => headers[key] ?? key;
+  const columnWidths = {};
+  for (const key of keys) {
+    const headerWidth = getStringWidth(getHeader(key));
+    let maxDataWidth = 0;
+    for (const row of data) {
+      const value = row[key];
+      const strValue = value === undefined || value === null ? "" : String(value);
+      const width = getStringWidth(strValue);
+      if (width > maxDataWidth) {
+        maxDataWidth = width;
+      }
+    }
+    const optionWidth = options?.columnWidths?.[key];
+    columnWidths[key] = optionWidth ?? Math.max(headerWidth, maxDataWidth);
+  }
+  const compact = options?.compact ?? false;
+  const borderStyle = compact ? "none" : options?.border ?? "single";
+  const chars = getBorderCharacters(borderStyle);
+  const hasBorders = borderStyle !== "none";
+  return hasBorders ? renderWithBorders(data, keys, columnWidths, getHeader, chars) : renderCompact(data, keys, columnWidths, getHeader);
+}
+function renderWithBorders(data, keys, columnWidths, getHeader, chars) {
+  const lines = [];
+  const colWidthsForBorder = keys.map((k) => (columnWidths[k] ?? 0) + 2);
+  lines.push(drawHorizontalBorder(chars, colWidthsForBorder, "top"));
+  lines.push(drawDataRow(keys.map((k) => getHeader(k)), keys.map((k) => columnWidths[k] ?? 0), chars.vertical));
+  lines.push(drawHorizontalBorder(chars, colWidthsForBorder, "middle"));
+  for (const row of data) {
+    const values = keys.map((k) => {
+      const value = row[k];
+      let strValue = value === undefined || value === null ? "" : String(value);
+      const width = columnWidths[k] ?? 0;
+      if (getStringWidth(strValue) > width) {
+        strValue = truncateText(strValue, width);
+      }
+      return strValue;
+    });
+    lines.push(drawDataRow(values, keys.map((k) => columnWidths[k] ?? 0), chars.vertical));
+  }
+  lines.push(drawHorizontalBorder(chars, colWidthsForBorder, "bottom"));
+  return lines.join(`
+`);
+}
+function renderCompact(data, keys, columnWidths, getHeader) {
+  const lines = [];
+  const headerValues = keys.map((k) => {
+    const header = getHeader(k);
+    const width = columnWidths[k] ?? 0;
+    return padText(header, width);
+  });
+  lines.push(headerValues.join("  "));
+  for (const row of data) {
+    const values = keys.map((k) => {
+      const value = row[k];
+      let strValue = value === undefined || value === null ? "" : String(value);
+      const width = columnWidths[k] ?? 0;
+      if (getStringWidth(strValue) > width) {
+        strValue = truncateText(strValue, width);
+      }
+      return padText(strValue, width);
+    });
+    lines.push(values.join("  "));
+  }
+  return lines.join(`
+`);
+}
+function drawHorizontalBorder(chars, colWidths, position) {
+  const positionChars = {
+    top: { left: chars.topLeft, right: chars.topRight, cross: chars.topT },
+    middle: { left: chars.leftT, right: chars.rightT, cross: chars.cross },
+    bottom: {
+      left: chars.bottomLeft,
+      right: chars.bottomRight,
+      cross: chars.bottomT
+    }
+  };
+  const { left, right, cross } = positionChars[position];
+  const segments = colWidths.map((w) => chars.horizontal.repeat(w));
+  return `${left}${segments.join(cross)}${right}`;
+}
+function drawDataRow(values, widths, vertical) {
+  const cells = values.map((value, i) => {
+    const width = widths[i] ?? 0;
+    return ` ${padText(value, width)} `;
+  });
+  return `${vertical}${cells.join(vertical)}${vertical}`;
+}
+
+export { renderTable };

package/dist/shared/@outfitter/tui-t9vd88jr.js

@@ -0,0 +1,273 @@
+// @bun
+import {
+  getBorderCharacters,
+  init_borders
+} from "./tui-2pwhzg55.js";
+import {
+  __esm,
+  __export
+} from "./tui-hescagw2.js";
+
+// packages/tui/src/render/box.ts
+var exports_box = {};
+__export(exports_box, {
+  renderBox: () => renderBox,
+  normalizePadding: () => normalizePadding,
+  normalizeMargin: () => normalizeMargin,
+  normalizeBorders: () => normalizeBorders,
+  createBox: () => createBox
+});
+import { getStringWidth, truncateText, wrapText } from "@outfitter/cli/text";
+function alignLine(line, width, align) {
+  const lineWidth = getStringWidth(line);
+  const padding = width - lineWidth;
+  if (padding <= 0) {
+    return line;
+  }
+  switch (align) {
+    case "center": {
+      const leftPad = Math.floor(padding / 2);
+      const rightPad = padding - leftPad;
+      return " ".repeat(leftPad) + line + " ".repeat(rightPad);
+    }
+    case "right":
+      return " ".repeat(padding) + line;
+    default:
+      return line + " ".repeat(padding);
+  }
+}
+function normalizePadding(padding, defaultValue) {
+  if (padding === undefined) {
+    return { top: 0, right: defaultValue, bottom: 0, left: defaultValue };
+  }
+  if (typeof padding === "number") {
+    return { top: 0, right: padding, bottom: 0, left: padding };
+  }
+  return {
+    top: padding.top ?? 0,
+    right: padding.right ?? defaultValue,
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? defaultValue
+  };
+}
+function normalizeMargin(margin, defaultValue) {
+  if (margin === undefined) {
+    return {
+      top: defaultValue,
+      right: defaultValue,
+      bottom: defaultValue,
+      left: defaultValue
+    };
+  }
+  if (typeof margin === "number") {
+    return { top: margin, right: margin, bottom: margin, left: margin };
+  }
+  return {
+    top: margin.top ?? defaultValue,
+    right: margin.right ?? defaultValue,
+    bottom: margin.bottom ?? defaultValue,
+    left: margin.left ?? defaultValue
+  };
+}
+function normalizeBorders(borders) {
+  if (borders === undefined) {
+    return { top: true, right: true, bottom: true, left: true };
+  }
+  return {
+    top: borders.top ?? true,
+    right: borders.right ?? true,
+    bottom: borders.bottom ?? true,
+    left: borders.left ?? true
+  };
+}
+function renderBox(content, options) {
+  const border = options?.border ?? "single";
+  const title = options?.title;
+  const align = options?.align ?? "left";
+  const fixedWidth = options?.width;
+  const sections = options?.sections;
+  const pad = normalizePadding(options?.padding, 1);
+  const margin = normalizeMargin(options?.margin, 0);
+  const borders = normalizeBorders(options?.borders);
+  const chars = getBorderCharacters(border);
+  let lines;
+  let sectionBoundaries = [];
+  if (sections && sections.length > 0) {
+    lines = [];
+    for (const [idx, section] of sections.entries()) {
+      const sectionLines = typeof section === "string" ? section.split(`
+`) : section;
+      lines.push(...sectionLines);
+      if (idx < sections.length - 1) {
+        sectionBoundaries.push(lines.length);
+      }
+    }
+  } else if (typeof content === "string") {
+    lines = content.split(`
+`);
+  } else {
+    lines = content;
+  }
+  const leftOverhead = (borders.left ? 1 : 0) + pad.left;
+  const rightOverhead = (borders.right ? 1 : 0) + pad.right;
+  const horizontalOverhead = leftOverhead + rightOverhead;
+  if (fixedWidth) {
+    const contentWidthForWrap = fixedWidth - horizontalOverhead;
+    if (contentWidthForWrap > 0) {
+      const wrappedLines = [];
+      const newBoundaries = [];
+      let boundaryIdx2 = 0;
+      let originalLineCount = 0;
+      for (const line of lines) {
+        if (getStringWidth(line) > contentWidthForWrap) {
+          const wrapped = wrapText(line, contentWidthForWrap);
+          wrappedLines.push(...wrapped.split(`
+`));
+        } else {
+          wrappedLines.push(line);
+        }
+        originalLineCount++;
+        const boundary = sectionBoundaries[boundaryIdx2];
+        if (boundary !== undefined && originalLineCount === boundary) {
+          newBoundaries.push(wrappedLines.length);
+          boundaryIdx2++;
+        }
+      }
+      lines = wrappedLines;
+      sectionBoundaries = newBoundaries;
+    }
+  }
+  let contentWidth = 0;
+  for (const line of lines) {
+    const w = getStringWidth(line);
+    if (w > contentWidth) {
+      contentWidth = w;
+    }
+  }
+  let boxWidth;
+  if (fixedWidth) {
+    boxWidth = fixedWidth;
+    contentWidth = fixedWidth - horizontalOverhead;
+  } else {
+    boxWidth = horizontalOverhead + contentWidth;
+    if (title && borders.top) {
+      const minBoxWidthForTitle = getStringWidth(title) + 4 + (borders.left ? 1 : 0) + (borders.right ? 1 : 0);
+      if (boxWidth < minBoxWidthForTitle) {
+        boxWidth = minBoxWidthForTitle;
+        contentWidth = boxWidth - horizontalOverhead;
+      }
+    }
+  }
+  const output = [];
+  const leftPaddingStr = " ".repeat(pad.left);
+  const rightPaddingStr = " ".repeat(pad.right);
+  const marginLeftStr = " ".repeat(margin.left);
+  const marginRightStr = " ".repeat(margin.right);
+  const buildContentLine = (lineContent) => {
+    const aligned = alignLine(lineContent, contentWidth, align);
+    const leftBorder = borders.left ? chars.vertical : "";
+    const rightBorder = borders.right ? chars.vertical : "";
+    return marginLeftStr + leftBorder + leftPaddingStr + aligned + rightPaddingStr + rightBorder + marginRightStr;
+  };
+  const innerWidth = boxWidth - (borders.left ? 1 : 0) - (borders.right ? 1 : 0);
+  for (let i = 0;i < margin.top; i++) {
+    output.push("");
+  }
+  if (borders.top) {
+    let topBorder;
+    if (title) {
+      const maxTitleWidth = Math.max(0, innerWidth - 4);
+      let displayTitle = title;
+      if (maxTitleWidth === 0) {
+        topBorder = marginLeftStr + (borders.left ? chars.topLeft : "") + chars.horizontal.repeat(Math.max(0, innerWidth)) + (borders.right ? chars.topRight : "") + marginRightStr;
+      } else {
+        if (getStringWidth(title) > maxTitleWidth) {
+          displayTitle = truncateText(title, maxTitleWidth);
+        }
+        const titlePart = `${chars.horizontal} ${displayTitle} `;
+        const remainingWidth = Math.max(0, innerWidth - getStringWidth(titlePart));
+        topBorder = marginLeftStr + (borders.left ? chars.topLeft : "") + titlePart + chars.horizontal.repeat(remainingWidth) + (borders.right ? chars.topRight : "") + marginRightStr;
+      }
+    } else {
+      topBorder = marginLeftStr + (borders.left ? chars.topLeft : "") + chars.horizontal.repeat(innerWidth) + (borders.right ? chars.topRight : "") + marginRightStr;
+    }
+    output.push(topBorder);
+  }
+  for (let i = 0;i < pad.top; i++) {
+    output.push(buildContentLine(""));
+  }
+  let boundaryIdx = 0;
+  for (const [idx, line] of lines.entries()) {
+    output.push(buildContentLine(line));
+    const boundary = sectionBoundaries[boundaryIdx];
+    if (boundary !== undefined && idx + 1 === boundary) {
+      const divider = marginLeftStr + (borders.left ? chars.leftT : "") + chars.horizontal.repeat(innerWidth) + (borders.right ? chars.rightT : "") + marginRightStr;
+      output.push(divider);
+      boundaryIdx++;
+    }
+  }
+  for (let i = 0;i < pad.bottom; i++) {
+    output.push(buildContentLine(""));
+  }
+  if (borders.bottom) {
+    const bottomBorder = marginLeftStr + (borders.left ? chars.bottomLeft : "") + chars.horizontal.repeat(innerWidth) + (borders.right ? chars.bottomRight : "") + marginRightStr;
+    output.push(bottomBorder);
+  }
+  for (let i = 0;i < margin.bottom; i++) {
+    output.push("");
+  }
+  return output.join(`
+`);
+}
+function isBox(value) {
+  return typeof value === "object" && value !== null && "output" in value && "width" in value && "height" in value && typeof value.output === "string" && typeof value.width === "number" && typeof value.height === "number";
+}
+function contentToLines(content) {
+  if (Array.isArray(content)) {
+    const lines = [];
+    for (const item of content) {
+      if (isBox(item)) {
+        lines.push(...item.output.split(`
+`));
+      } else if (Array.isArray(item)) {
+        lines.push(...item);
+      } else {
+        lines.push(...item.split(`
+`));
+      }
+    }
+    return lines;
+  }
+  if (isBox(content)) {
+    return content.output.split(`
+`);
+  }
+  if (typeof content === "string") {
+    return content.split(`
+`);
+  }
+  return content;
+}
+function createBox(content, options) {
+  const lines = contentToLines(content);
+  const output = renderBox(lines, options);
+  const outputLines = output.split(`
+`);
+  let maxWidth = 0;
+  for (const line of outputLines) {
+    const lineWidth = getStringWidth(line);
+    if (lineWidth > maxWidth) {
+      maxWidth = lineWidth;
+    }
+  }
+  return {
+    output,
+    width: maxWidth,
+    height: outputLines.length
+  };
+}
+var init_box = __esm(() => {
+  init_borders();
+});
+
+export { normalizePadding, normalizeMargin, normalizeBorders, renderBox, createBox, exports_box, init_box };

package/dist/shared/@outfitter/tui-tq1z78x0.js

@@ -0,0 +1,11 @@
+// @bun
+// packages/tui/src/render/json.ts
+function renderJson(data) {
+  const json = JSON.stringify(data, null, 2);
+  return json;
+}
+function renderText(text) {
+  return text;
+}
+
+export { renderJson, renderText };

package/dist/shared/@outfitter/tui-ts1f957s.d.ts

@@ -0,0 +1,128 @@
+import { CaseMode, SeparatorStyle } from "./tui-jz5nws55";
+import { Theme } from "@outfitter/cli/colors";
+/**
+* Options for creating a demo section.
+*/
+interface SectionOptions {
+	/** Separator character style (default: "─") */
+	separator?: SeparatorStyle;
+	/** Case transformation (default: "title") */
+	case?: CaseMode;
+}
+/**
+* Options for creating a subsection.
+*/
+interface SubsectionOptions {
+	/** Separator character style (default: "─") */
+	separator?: SeparatorStyle;
+	/** Case transformation (default: "title") */
+	case?: CaseMode;
+}
+/**
+* Creates a demo section heading.
+*
+* Sections are major divisions in a demo, rendered with title case text
+* and thin Unicode line separators by default.
+*
+* @param title - The section title
+* @param options - Optional rendering options
+* @returns Formatted section heading string
+*
+* @example
+* ```typescript
+* import { demoSection } from "@outfitter/tui/demo";
+*
+* console.log(demoSection("Theme Colors"));
+* // Theme Colors
+* // ────────────
+* ```
+*/
+declare function demoSection(title: string, options?: SectionOptions): string;
+/**
+* Creates a demo subsection heading.
+*
+* Subsections are minor divisions within a section, rendered with title case
+* text and thin Unicode line separators by default.
+*
+* @param title - The subsection title
+* @param options - Optional rendering options
+* @returns Formatted subsection heading string
+*
+* @example
+* ```typescript
+* import { demoSubsection } from "@outfitter/tui/demo";
+*
+* console.log(demoSubsection("Status"));
+* // Status
+* // ──────
+* ```
+*/
+declare function demoSubsection(title: string, options?: SubsectionOptions): string;
+/**
+* Creates a code block for demo sections.
+*
+* Code blocks are displayed when `showCode` is enabled and provide
+* usage examples for the primitives being demonstrated.
+*
+* @param lines - Lines of code to display
+* @param show - Whether to show the code block (default: true)
+* @returns Array of code lines, or empty array if hidden
+*
+* @example
+* ```typescript
+* import { codeBlock } from "@outfitter/tui/demo";
+*
+* const code = codeBlock([
+*   'import { renderBox } from "@outfitter/tui/render";',
+*   "",
+*   'renderBox("Hello")',
+* ], true);
+* ```
+*/
+declare function codeBlock(lines: string[], show?: boolean): string[];
+/**
+* Creates a description line styled with muted theme.
+*
+* Descriptions provide contextual information about a demo section
+* when `showDescriptions` is enabled.
+*
+* @param text - The description text
+* @param theme - Theme for styling
+* @param show - Whether to show the description (default: true)
+* @returns Array with styled description, or empty array if hidden
+*
+* @example
+* ```typescript
+* import { description } from "@outfitter/tui/demo";
+*
+* const desc = description(
+*   "Control padding per side with an object.",
+*   theme,
+*   true
+* );
+* ```
+*/
+declare function description(text: string, theme: Theme, show?: boolean): string[];
+/**
+* Joins demo content with vertical spacing.
+*
+* Wraps `joinVertical` with demo-appropriate defaults.
+*
+* @param blocks - Content blocks to join
+* @param gap - Lines of spacing between blocks (default: 1)
+* @returns Combined string with blocks stacked
+*
+* @example
+* ```typescript
+* import { demoSection, demoContent } from "@outfitter/tui/demo";
+*
+* const output = demoContent([
+*   demoSection("Colors"),
+*   "Color examples here...",
+*   demoSection("Borders"),
+*   "Border examples here...",
+* ]);
+* ```
+*/
+declare function demoContent(blocks: string[], gap?: number): string;
+export { SectionOptions, SubsectionOptions, demoSection, demoSubsection, codeBlock, description, demoContent };

package/dist/shared/@outfitter/tui-ve0083wa.d.ts

@@ -0,0 +1,61 @@
+import { PartialVisualTheme, VisualTheme } from "./tui-8j1gbehy";
+/**
+* Options for creating a visual theme.
+*/
+interface CreateVisualThemeOptions {
+	/**
+	* Base theme to extend from.
+	* Properties not overridden will be inherited from this theme.
+	* @default defaultTheme
+	*/
+	extends?: VisualTheme;
+	/**
+	* Properties to override on the base/extended theme.
+	* Supports partial overrides for nested objects (colors, spacing, markers).
+	*/
+	overrides?: PartialVisualTheme;
+}
+/**
+* Creates a visual theme by extending and/or overriding a base theme.
+*
+* This is the primary factory for creating custom themes. You can:
+* - Start from scratch (no options → defaultTheme)
+* - Extend an existing preset
+* - Override specific properties
+* - Combine extension and overrides
+*
+* When changing the `border` property, `borderChars` is automatically
+* updated to match the new border style.
+*
+* @param options - Configuration for theme creation
+* @returns A complete VisualTheme
+*
+* @example
+* ```typescript
+* // Start with defaults
+* const theme = createVisualTheme();
+*
+* // Extend a preset
+* const rounded = createVisualTheme({ extends: roundedTheme });
+*
+* // Override specific properties
+* const custom = createVisualTheme({
+*   overrides: {
+*     border: "double",
+*     colors: { success: "\x1b[38;5;82m" },
+*     spacing: { boxPadding: 2 }
+*   }
+* });
+*
+* // Extend and override
+* const brandTheme = createVisualTheme({
+*   extends: roundedTheme,
+*   overrides: {
+*     name: "brand",
+*     colors: { accent: "\x1b[38;5;39m" }
+*   }
+* });
+* ```
+*/
+declare function createVisualTheme(options?: CreateVisualThemeOptions): VisualTheme;
+export { CreateVisualThemeOptions, createVisualTheme };

package/dist/shared/@outfitter/tui-vt0wg6c4.js

@@ -0,0 +1,54 @@
+// @bun
+// packages/tui/src/render/markdown.ts
+import { ANSI } from "@outfitter/cli/colors";
+import { supportsColor } from "@outfitter/cli/terminal";
+function renderMarkdown(markdown) {
+  const colorEnabled = supportsColor();
+  let result = markdown;
+  result = result.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, _lang, code) => {
+    const trimmed = code.trimEnd();
+    if (colorEnabled) {
+      return `${ANSI.dim}${trimmed}${ANSI.reset}`;
+    }
+    return trimmed;
+  });
+  result = result.replace(/^(#{1,6})\s+(.+)$/gm, (_match, _hashes, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/\*\*(.+?)\*\*/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/__(.+?)__/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.bold}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.italic}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/(?<!_)_([^_]+)_(?!_)/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.italic}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  result = result.replace(/`([^`]+)`/g, (_match, text) => {
+    if (colorEnabled) {
+      return `${ANSI.cyan}${text}${ANSI.reset}`;
+    }
+    return text;
+  });
+  return result;
+}
+
+export { renderMarkdown };