@outfitter/tui 0.2.0

package/dist/shared/@outfitter/tui-8mypsnva.d.ts

@@ -0,0 +1,74 @@
+/**
+* Validator factories for prompt input validation.
+*
+* @packageDocumentation
+*/
+/**
+* A validator function that returns an error message or undefined.
+*/
+type Validator = (value: string) => string | undefined;
+/**
+* Collection of validator factory functions.
+*
+* @example
+* ```typescript
+* import { validators } from "@outfitter/tui/prompt";
+*
+* const validate = validators.compose(
+*   validators.required(),
+*   validators.minLength(3),
+*   validators.email()
+* );
+*
+* const error = validate("ab");
+* // "Minimum 3 characters"
+* ```
+*/
+declare const validators: {
+	/**
+	* Requires a non-empty value.
+	*
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	required: (message?: string) => Validator;
+	/**
+	* Requires minimum character length.
+	*
+	* @param length - Minimum length
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	minLength: (length: number, message?: string) => Validator;
+	/**
+	* Requires maximum character length.
+	*
+	* @param length - Maximum length
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	maxLength: (length: number, message?: string) => Validator;
+	/**
+	* Requires value to match a regex pattern.
+	*
+	* @param regex - Pattern to match
+	* @param message - Error message when pattern doesn't match
+	* @returns Validator function
+	*/
+	pattern: (regex: RegExp, message: string) => Validator;
+	/**
+	* Validates email format.
+	*
+	* @param message - Custom error message
+	* @returns Validator function
+	*/
+	email: (message?: string) => Validator;
+	/**
+	* Composes multiple validators, returning the first error.
+	*
+	* @param fns - Validators to compose
+	* @returns Combined validator function
+	*/
+	compose: (...fns: Validator[]) => Validator;
+};
+export { Validator, validators };

package/dist/shared/@outfitter/tui-997aapz0.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  demoSection
+} from "./tui-733asbd8.js";
+import {
+  renderProgress
+} from "./tui-qb07rtct.js";
+
+// packages/tui/src/demo/renderers/progress.ts
+function renderProgressDemo(config, _theme) {
+  const showCode = config.showCode ?? true;
+  const lines = [];
+  lines.push(demoSection("Basic Progress Bar"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { renderProgress } from "@outfitter/tui/render";');
+    lines.push("");
+  }
+  const percentages = [0, 25, 50, 75, 100];
+  for (const pct of percentages) {
+    const bar = renderProgress({ current: pct, total: 100 });
+    lines.push(`${pct.toString().padStart(3)}% ${bar}`);
+  }
+  lines.push("");
+  lines.push(demoSection("With Percentage Display"));
+  lines.push("");
+  if (showCode) {
+    lines.push("renderProgress({ current: 75, total: 100, showPercent: true })");
+    lines.push("");
+  }
+  lines.push(renderProgress({ current: 75, total: 100, showPercent: true }));
+  lines.push("");
+  lines.push(demoSection("Custom Width"));
+  lines.push("");
+  const widths = [10, 20, 30, 40];
+  for (const width of widths) {
+    if (showCode) {
+      lines.push(`renderProgress({ current: 50, total: 100, width: ${width} })`);
+    }
+    const bar = renderProgress({ current: 50, total: 100, width });
+    lines.push(`  ${bar}`);
+    lines.push("");
+  }
+  lines.push(demoSection("Edge Cases"));
+  lines.push("");
+  lines.push("Empty (0%):");
+  lines.push(`  ${renderProgress({ current: 0, total: 100 })}`);
+  lines.push("");
+  lines.push("Full (100%):");
+  lines.push(`  ${renderProgress({ current: 100, total: 100 })}`);
+  lines.push("");
+  lines.push("Over 100% (capped):");
+  lines.push(`  ${renderProgress({ current: 150, total: 100, showPercent: true })}`);
+  lines.push("");
+  lines.push("Negative (floored to 0%):");
+  lines.push(`  ${renderProgress({ current: -10, total: 100, showPercent: true })}`);
+  return lines.join(`
+`);
+}
+
+export { renderProgressDemo };

package/dist/shared/@outfitter/tui-9dbykt4g.d.ts

@@ -0,0 +1,42 @@
+/**
+* Formatting utilities for human-readable output.
+*
+* Provides functions to format durations and byte sizes.
+*
+* @packageDocumentation
+*/
+/**
+* Formats milliseconds as human-readable duration.
+*
+* Converts milliseconds to a compact, human-friendly format using
+* h (hours), m (minutes), s (seconds), or ms (milliseconds).
+*
+* @param ms - Duration in milliseconds
+* @returns Human-friendly duration string
+*
+* @example
+* ```typescript
+* formatDuration(150)     // "150ms"
+* formatDuration(45000)   // "45s"
+* formatDuration(9015000) // "2h 30m 15s"
+* ```
+*/
+declare function formatDuration(ms: number): string;
+/**
+* Formats bytes as human-readable size.
+*
+* Converts bytes to a compact format using appropriate units
+* (B, KB, MB, GB, TB). Uses 1024-based (binary) units.
+*
+* @param bytes - Size in bytes
+* @returns Human-friendly size string
+*
+* @example
+* ```typescript
+* formatBytes(500)        // "500 B"
+* formatBytes(1536)       // "1.5 KB"
+* formatBytes(1073741824) // "1 GB"
+* ```
+*/
+declare function formatBytes(bytes: number): string;
+export { formatDuration, formatBytes };

package/dist/shared/@outfitter/tui-9h1kdd98.d.ts

@@ -0,0 +1,119 @@
+/**
+* Indicator primitives for CLI output.
+*
+* Provides status symbols, selection indicators, list bullets, and progress
+* markers with unicode and ASCII fallback support.
+*
+* @packageDocumentation
+*/
+/**
+* Categories of indicators available.
+*/
+type IndicatorCategory = "status" | "marker" | "progress" | "triangle" | "special" | "directional" | "math";
+/**
+* An indicator with unicode and fallback representations.
+*/
+interface IndicatorSet {
+	/** Unicode character for modern terminals */
+	unicode: string;
+	/** ASCII fallback for limited terminals */
+	fallback: string;
+	/** Optional semantic color name */
+	color?: string;
+}
+/**
+* All available indicators organized by category.
+*
+* @example
+* ```typescript
+* import { INDICATORS, getIndicator } from "@outfitter/tui/render";
+*
+* // Access directly
+* console.log(INDICATORS.status.success.unicode); // "✔"
+*
+* // Or use helper
+* console.log(getIndicator("status", "success")); // "✔" or "[ok]"
+* ```
+*/
+declare const INDICATORS: Record<IndicatorCategory, Record<string, IndicatorSet>>;
+/**
+* Detects if the terminal supports Unicode characters.
+*
+* Checks for:
+* - CI environments (usually support unicode)
+* - Windows Terminal / ConEmu
+* - TERM containing xterm/vt100
+* - Locale settings
+*
+* @returns true if unicode is likely supported
+*/
+declare function isUnicodeSupported(): boolean;
+/**
+* Gets an indicator character with automatic unicode/fallback selection.
+*
+* @param category - The indicator category
+* @param name - The indicator name within the category
+* @param forceUnicode - Override unicode detection (useful for testing)
+* @returns The appropriate character for the current terminal
+*
+* @example
+* ```typescript
+* // Automatic detection
+* console.log(getIndicator("status", "success"));
+*
+* // Force unicode
+* console.log(getIndicator("status", "success", true)); // "✔"
+*
+* // Force fallback
+* console.log(getIndicator("status", "success", false)); // "[ok]"
+* ```
+*/
+declare function getIndicator(category: IndicatorCategory, name: string, forceUnicode?: boolean): string;
+/**
+* Progress indicator styles.
+*/
+type ProgressStyle = "circle" | "vertical" | "horizontal" | "shade";
+/**
+* Gets a progress indicator based on current/max values.
+*
+* @param style - The progress style (circle, vertical, horizontal, shade)
+* @param current - Current progress value
+* @param max - Maximum progress value
+* @param forceUnicode - Override unicode detection
+* @returns The appropriate progress indicator character
+*
+* @example
+* ```typescript
+* // Circle progress at 50%
+* getProgressIndicator("circle", 50, 100); // "◑"
+*
+* // Vertical block at 75%
+* getProgressIndicator("vertical", 6, 8); // "▆"
+*
+* // Horizontal bar at 100%
+* getProgressIndicator("horizontal", 1, 1); // "█"
+* ```
+*/
+declare function getProgressIndicator(style: ProgressStyle, current: number, max: number, forceUnicode?: boolean): string;
+/**
+* Severity levels for escalating indicators.
+*
+* Uses the diamond family: ◇ (minor) → ◆ (moderate) → ◈ (severe)
+*/
+type SeverityLevel = "minor" | "moderate" | "severe";
+/**
+* Gets a severity indicator for the given level.
+*
+* @param level - The severity level
+* @param forceUnicode - Override unicode detection
+* @returns The appropriate severity indicator character
+*
+* @example
+* ```typescript
+* getSeverityIndicator("minor");    // "◇"
+* getSeverityIndicator("moderate"); // "◆"
+* getSeverityIndicator("severe");   // "◈"
+* ```
+*/
+declare function getSeverityIndicator(level: SeverityLevel, forceUnicode?: boolean): string;
+export { IndicatorCategory, IndicatorSet, INDICATORS, isUnicodeSupported, getIndicator, ProgressStyle, getProgressIndicator, SeverityLevel, getSeverityIndicator };

package/dist/shared/@outfitter/tui-9rj9yesd.js

@@ -0,0 +1,118 @@
+// @bun
+import {
+  demoSection,
+  demoSubsection
+} from "./tui-733asbd8.js";
+import {
+  INDICATORS,
+  getIndicator,
+  getProgressIndicator
+} from "./tui-pdwbbzwr.js";
+
+// packages/tui/src/demo/renderers/indicators.ts
+function renderIndicatorsDemo(config, _theme) {
+  const showCode = config.showCode ?? true;
+  const lines = [];
+  lines.push(demoSection("Indicators"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { getIndicator, getProgressIndicator, INDICATORS } from "@outfitter/tui/render";');
+    lines.push("");
+  }
+  lines.push("Semantic indicators with Unicode and ASCII fallback support.");
+  lines.push("");
+  lines.push(demoSubsection("Status"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.status)) {
+    const colorInfo = indicator.color ? ` (${indicator.color})` : "";
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(10)} \u2192 ${indicator.fallback}${colorInfo}`);
+  }
+  lines.push("");
+  if (showCode) {
+    lines.push('getIndicator("status", "success")  // ' + getIndicator("status", "success", true));
+    lines.push('getIndicator("status", "error")    // ' + getIndicator("status", "error", true));
+    lines.push("");
+  }
+  lines.push(demoSubsection("Markers"));
+  lines.push("");
+  const markerGroups = {
+    Circles: [
+      "circle",
+      "circleOutline",
+      "circleDotted",
+      "circleSmall",
+      "circleDot",
+      "circleDotOutline"
+    ],
+    Squares: ["square", "squareOutline", "squareSmall", "squareSmallOutline"],
+    Lozenges: ["lozenge", "lozengeOutline"],
+    Checkboxes: ["checkbox", "checkboxChecked", "checkboxCross"],
+    Pointers: ["pointer", "pointerSmall", "dash"]
+  };
+  for (const [groupName, names] of Object.entries(markerGroups)) {
+    lines.push(`  ${groupName}:`);
+    for (const name of names) {
+      const indicator = INDICATORS.marker[name];
+      if (indicator) {
+        lines.push(`    ${indicator.unicode}  ${name.padEnd(18)} \u2192 ${indicator.fallback}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(demoSubsection("Progress"));
+  lines.push("");
+  lines.push("  Circle:     \u25CB \u25D4 \u25D1 \u25D5 \u25CF");
+  lines.push("  Vertical:   \u2581 \u2582 \u2583 \u2584 \u2585 \u2586 \u2587 \u2588");
+  lines.push("  Horizontal: \u258F \u258E \u258D \u258C \u258B \u258A \u2589 \u2588");
+  lines.push("  Shade:      \u2591 \u2592 \u2593");
+  lines.push("");
+  if (showCode) {
+    lines.push("// Get progress indicator by percentage:");
+    lines.push('getProgressIndicator("circle", 50, 100)      // ' + getProgressIndicator("circle", 50, 100, true));
+    lines.push('getProgressIndicator("vertical", 6, 8)      // ' + getProgressIndicator("vertical", 6, 8, true));
+    lines.push('getProgressIndicator("horizontal", 4, 8)    // ' + getProgressIndicator("horizontal", 4, 8, true));
+    lines.push('getProgressIndicator("shade", 100, 100)     // ' + getProgressIndicator("shade", 100, 100, true));
+    lines.push("");
+  }
+  lines.push(demoSubsection("Triangles"));
+  lines.push("");
+  const triangleGroups = {
+    Up: ["up", "upSmall", "upOutline"],
+    Down: ["down", "downSmall", "downOutline"],
+    Left: ["left", "leftSmall", "leftOutline"],
+    Right: ["right", "rightSmall", "rightOutline"]
+  };
+  for (const [groupName, names] of Object.entries(triangleGroups)) {
+    const indicators = names.map((n) => INDICATORS.triangle[n]?.unicode ?? "").join("  ");
+    lines.push(`  ${groupName.padEnd(6)} ${indicators}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Special"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.special)) {
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(14)} \u2192 ${indicator.fallback}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Directional"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.directional)) {
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(16)} \u2192 ${indicator.fallback}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Math"));
+  lines.push("");
+  for (const [name, indicator] of Object.entries(INDICATORS.math)) {
+    lines.push(`  ${indicator.unicode}  ${name.padEnd(16)} \u2192 ${indicator.fallback}`);
+  }
+  lines.push("");
+  lines.push(demoSubsection("Usage"));
+  lines.push("");
+  lines.push("\u2022 getIndicator(category, name) \u2014 auto-detects Unicode support");
+  lines.push("\u2022 getProgressIndicator(style, current, max) \u2014 maps value to step");
+  lines.push("\u2022 INDICATORS[category][name] \u2014 direct access to unicode/fallback");
+  lines.push("\u2022 Status indicators include semantic color hints");
+  return lines.join(`
+`);
+}
+
+export { renderIndicatorsDemo };

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

@@ -0,0 +1,23 @@
+import { ConfirmPromptOptions, PromptResult } from "./tui-c56sxcm8";
+/**
+* Prompts for yes/no confirmation with Result wrapping.
+*
+* @param options - Confirm prompt options
+* @returns Ok with boolean or Err with CancelledError
+*
+* @example
+* ```typescript
+* import { promptConfirm } from "@outfitter/tui/prompt";
+*
+* const result = await promptConfirm({
+*   message: "Are you sure you want to continue?",
+*   initialValue: false,
+* });
+*
+* if (result.isOk() && result.value) {
+*   console.log("Continuing...");
+* }
+* ```
+*/
+declare function promptConfirm(options: ConfirmPromptOptions): PromptResult<boolean>;
+export { promptConfirm };

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

@@ -0,0 +1 @@
+// @bun

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

@@ -0,0 +1,59 @@
+import { GlyphPair, SemanticState, VisualTheme } from "./tui-8j1gbehy";
+/**
+* Resolves a glyph pair to a single character based on terminal capability.
+*
+* Uses terminal detection to choose between unicode and fallback characters.
+* Can be overridden with the `forceUnicode` parameter.
+*
+* @param glyph - The glyph pair to resolve
+* @param forceUnicode - Override terminal detection (true = unicode, false = fallback)
+* @returns The appropriate character for the terminal
+*
+* @example
+* ```typescript
+* const bullet: GlyphPair = { unicode: "•", fallback: "*" };
+*
+* // Auto-detect terminal capability
+* resolveGlyph(bullet);       // "•" or "*" based on terminal
+*
+* // Force unicode
+* resolveGlyph(bullet, true);  // "•"
+*
+* // Force fallback
+* resolveGlyph(bullet, false); // "*"
+* ```
+*/
+declare function resolveGlyph(glyph: GlyphPair, forceUnicode?: boolean): string;
+/**
+* Resolves a semantic state to its visual marker character.
+*
+* Looks up the marker specification in the theme and returns the
+* appropriate character. Supports both indicator-type markers (from
+* the INDICATORS registry) and custom glyph pairs.
+*
+* @param theme - The visual theme containing marker definitions
+* @param state - The semantic state to resolve
+* @param forceUnicode - Override terminal detection
+* @returns The marker character for the given state
+*
+* @example
+* ```typescript
+* import { defaultTheme, resolveStateMarker } from "@outfitter/tui/theme";
+*
+* // Resolve success marker (indicator-type)
+* resolveStateMarker(defaultTheme, "success", true);  // "✔"
+* resolveStateMarker(defaultTheme, "success", false); // "[ok]"
+*
+* // Resolve with custom theme marker
+* const theme = createVisualTheme({
+*   overrides: {
+*     markers: {
+*       current: { type: "custom", glyph: { unicode: "★", fallback: "*" } }
+*     }
+*   }
+* });
+* resolveStateMarker(theme, "current", true); // "★"
+* ```
+*/
+declare function resolveStateMarker(theme: VisualTheme, state: SemanticState, forceUnicode?: boolean): string;
+export { resolveGlyph, resolveStateMarker };

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

@@ -0,0 +1,30 @@
+/**
+* Renders markdown to terminal with ANSI styling.
+*
+* Supports the following markdown elements:
+* - Headings (`# Heading`) - rendered bold
+* - Bold (`**text**` or `__text__`) - rendered bold
+* - Italic (`*text*` or `_text_`) - rendered italic
+* - Inline code (`` `code` ``) - rendered cyan
+* - Code blocks (` ``` `) - rendered dim
+*
+* When colors are not supported, markdown syntax is stripped
+* but text content is preserved.
+*
+* @param markdown - Markdown text to render
+* @returns Terminal-formatted string with ANSI codes
+*
+* @example
+* ```typescript
+* const md = `# Heading
+*
+* Some **bold** and *italic* text.
+*
+* Use \`npm install\` to install.
+* `;
+*
+* console.log(renderMarkdown(md));
+* ```
+*/
+declare function renderMarkdown(markdown: string): string;
+export { renderMarkdown };

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

@@ -0,0 +1,67 @@
+// @bun
+import {
+  getExample
+} from "./tui-nprd7g0d.js";
+import {
+  demoSection
+} from "./tui-733asbd8.js";
+import {
+  SPINNER_STYLE_META,
+  getSpinnerStyles
+} from "./tui-nr580mbv.js";
+import {
+  SPINNERS,
+  getSpinnerFrame,
+  renderSpinner
+} from "./tui-5pb72vf9.js";
+
+// packages/tui/src/demo/renderers/spinner.ts
+function renderSpinnerDemo(config, theme) {
+  const showCode = config.showCode ?? true;
+  const showDescriptions = config.showDescriptions ?? true;
+  const lines = [];
+  lines.push(demoSection("Spinner Styles"));
+  lines.push("");
+  if (showCode) {
+    lines.push('import { renderSpinner, SPINNERS } from "@outfitter/tui/render";');
+    lines.push("");
+  }
+  const message = getExample("spinnerMessage", config.examples);
+  const styles = getSpinnerStyles();
+  for (const style of styles) {
+    const meta = SPINNER_STYLE_META[style];
+    const spinner = SPINNERS[style];
+    lines.push(`${meta.label.toUpperCase()} (${style})`);
+    if (showDescriptions) {
+      lines.push(theme.muted(meta.description));
+    }
+    const frameDisplay = spinner.frames.join(" ");
+    lines.push(`  Frames: ${frameDisplay}`);
+    lines.push(`  Interval: ${spinner.interval}ms`);
+    const output = renderSpinner(style, message);
+    lines.push(`  Example: ${output}`);
+    lines.push("");
+  }
+  lines.push(demoSection("Usage"));
+  lines.push("");
+  if (showCode) {
+    lines.push("// Static render (for logs/non-TTY)");
+    lines.push(`renderSpinner("dots", "${message}");`);
+    lines.push("");
+    lines.push("// Get frame at specific time");
+    lines.push('getSpinnerFrame("dots", 0);     // First frame');
+    lines.push('getSpinnerFrame("dots", 160);   // Third frame');
+    lines.push("");
+  }
+  lines.push("Frame progression (dots style):");
+  const dotSpinner = SPINNERS.dots;
+  for (let i = 0;i < Math.min(5, dotSpinner.frames.length); i++) {
+    const elapsed = i * dotSpinner.interval;
+    const frame = getSpinnerFrame("dots", elapsed);
+    lines.push(`  ${elapsed}ms \u2192 ${frame}`);
+  }
+  return lines.join(`
+`);
+}
+
+export { renderSpinnerDemo };

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

@@ -0,0 +1,53 @@
+/**
+* Minimal writable stream interface.
+*/
+interface WritableStream {
+	write(str: string): boolean;
+	isTTY?: boolean;
+}
+/**
+* Options for creating a stream writer.
+*/
+interface StreamWriterOptions {
+	/** Target stream (defaults to process.stdout) */
+	stream?: WritableStream;
+}
+/**
+* Interface for managing in-place terminal output.
+*/
+interface StreamWriter {
+	/** Write content (replaces current content) */
+	write(content: string): void;
+	/** Update content in place */
+	update(content: string): void;
+	/** Persist current content and move to new line */
+	persist(): void;
+	/** Clear current content */
+	clear(): void;
+}
+/**
+* Creates a stream writer for in-place terminal updates.
+*
+* The writer tracks the number of lines written and can update them in place.
+* In non-TTY mode, it falls back to simple line-by-line output.
+*
+* @param options - Writer configuration
+* @returns StreamWriter instance
+*
+* @example
+* ```typescript
+* import { createStreamWriter } from "@outfitter/tui/streaming";
+*
+* const writer = createStreamWriter();
+*
+* writer.write("Processing...");
+* // Do some work
+* writer.update("Processing... 50%");
+* // Do more work
+* writer.update("Processing... 100%");
+* writer.persist();
+* writer.write("Done!");
+* ```
+*/
+declare function createStreamWriter(options?: StreamWriterOptions): StreamWriter;
+export { WritableStream, StreamWriterOptions, StreamWriter, createStreamWriter };