@outfitter/tui 0.2.0

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

@@ -0,0 +1,135 @@
+// @bun
+import {
+  renderTree
+} from "./tui-kydbggmj.js";
+import {
+  renderJson,
+  renderText
+} from "./tui-tq1z78x0.js";
+import {
+  renderMarkdown
+} from "./tui-vt0wg6c4.js";
+import {
+  renderList
+} from "./tui-5dsn6d6d.js";
+import {
+  renderTable
+} from "./tui-t1a9xgbd.js";
+
+// packages/tui/src/render/shapes.ts
+function isCollection(shape) {
+  return shape.type === "collection";
+}
+function isHierarchy(shape) {
+  return shape.type === "hierarchy";
+}
+function isKeyValue(shape) {
+  return shape.type === "keyvalue";
+}
+function isResource(shape) {
+  return shape.type === "resource";
+}
+function treeNodeToRecord(node) {
+  if (node.children.length === 0) {
+    return { [node.name]: null };
+  }
+  const childRecord = {};
+  for (const child of node.children) {
+    const childObj = treeNodeToRecord(child);
+    Object.assign(childRecord, childObj);
+  }
+  return { [node.name]: childRecord };
+}
+function isPlainObject(item) {
+  return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+var customRenderers = new Map;
+function registerRenderer(shapeType, renderer) {
+  customRenderers.set(shapeType, renderer);
+}
+function unregisterRenderer(shapeType) {
+  return customRenderers.delete(shapeType);
+}
+function clearRenderers() {
+  customRenderers.clear();
+}
+function render(shape, options) {
+  const customRenderer = customRenderers.get(shape.type);
+  if (customRenderer) {
+    return customRenderer(shape, options);
+  }
+  const format = options?.format;
+  if (format === "json") {
+    if (isCollection(shape)) {
+      return renderJson(shape.items);
+    }
+    if (isHierarchy(shape)) {
+      return renderJson(treeNodeToRecord(shape.root));
+    }
+    if (isKeyValue(shape)) {
+      return renderJson(shape.entries);
+    }
+    if (isResource(shape)) {
+      return renderJson(shape.data);
+    }
+  }
+  if (format === "list" && isCollection(shape)) {
+    const listItems = shape.items.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (isPlainObject(item)) {
+        const name = item.name;
+        if (typeof name === "string") {
+          return name;
+        }
+        return JSON.stringify(item);
+      }
+      return String(item);
+    });
+    return renderList(listItems);
+  }
+  if (format === "table" && isCollection(shape)) {
+    const items = shape.items.filter(isPlainObject);
+    return renderTable(items, shape.headers ? { headers: shape.headers } : undefined);
+  }
+  if (format === "tree" && isHierarchy(shape)) {
+    return renderTree(treeNodeToRecord(shape.root));
+  }
+  if (format === "text" && isResource(shape)) {
+    return renderText(String(shape.data));
+  }
+  if (isCollection(shape)) {
+    const hasObjectItems = shape.items.every(isPlainObject);
+    if (hasObjectItems) {
+      const items = shape.items;
+      return renderTable(items, shape.headers ? { headers: shape.headers } : undefined);
+    }
+    const listItems = shape.items.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      return String(item);
+    });
+    return renderList(listItems);
+  }
+  if (isHierarchy(shape)) {
+    return renderTree(treeNodeToRecord(shape.root));
+  }
+  if (isKeyValue(shape)) {
+    return renderJson(shape.entries);
+  }
+  if (isResource(shape)) {
+    const resourceFormat = shape.format ?? "json";
+    if (resourceFormat === "markdown") {
+      return renderMarkdown(String(shape.data));
+    }
+    if (resourceFormat === "text") {
+      return renderText(String(shape.data));
+    }
+    return renderJson(shape.data);
+  }
+  return renderJson(shape);
+}
+
+export { isCollection, isHierarchy, isKeyValue, isResource, treeNodeToRecord, isPlainObject, registerRenderer, unregisterRenderer, clearRenderers, render };

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

@@ -0,0 +1,112 @@
+import { Theme } from "@outfitter/cli/colors";
+/**
+* Available primitive types for demos.
+*/
+type PrimitiveId = "colors" | "borders" | "spinner" | "list" | "box" | "table" | "progress" | "tree" | "text" | "markdown" | "indicators";
+/**
+* Categorization for theme methods.
+*/
+type ThemeMethodCategory = "semantic" | "utility";
+/**
+* Metadata for a theme method.
+*/
+interface ThemeMethodMeta {
+	/** Method category (semantic or utility) */
+	category: ThemeMethodCategory;
+	/** Human-readable description */
+	description: string;
+	/** Default example text */
+	defaultExample: string;
+}
+/**
+* Metadata for a primitive variant (spinner styles, border styles, etc).
+*/
+interface VariantMeta<T extends string> {
+	/** The variant value */
+	value: T;
+	/** Human-readable label */
+	label: string;
+	/** Description of the variant */
+	description: string;
+}
+/**
+* Metadata describing a primitive for demo generation.
+*/
+interface PrimitiveMeta {
+	/** Primitive identifier */
+	id: PrimitiveId;
+	/** Human-readable name */
+	name: string;
+	/** Brief description */
+	description: string;
+	/** Import statement example */
+	importExample: string;
+}
+/**
+* Customizable example texts for demos.
+*
+* Keys correspond to theme method names and other example contexts.
+*/
+interface ExampleTexts {
+	success: string;
+	warning: string;
+	error: string;
+	info: string;
+	primary: string;
+	secondary: string;
+	muted: string;
+	accent: string;
+	highlight: string;
+	link: string;
+	destructive: string;
+	subtle: string;
+	bold: string;
+	italic: string;
+	underline: string;
+	dim: string;
+	boxContent: string;
+	boxTitle: string;
+	spinnerMessage: string;
+	progressLabel: string;
+	listItems: string[];
+	tableData: Record<string, unknown>[];
+	treeData: Record<string, unknown>;
+	markdownSample: string;
+}
+/**
+* Configuration for demo rendering.
+*/
+interface DemoConfig {
+	/**
+	* Override default example texts.
+	*/
+	examples?: Partial<ExampleTexts>;
+	/**
+	* Whether to show import statements.
+	* @default true
+	*/
+	showCode?: boolean;
+	/**
+	* Whether to show method/variant descriptions.
+	* @default true
+	*/
+	showDescriptions?: boolean;
+}
+/**
+* Function that renders a demo section for a primitive.
+*/
+type DemoRenderer = (config: DemoConfig, theme: Theme) => string;
+/**
+* Registry entry for a primitive demo.
+*/
+interface DemoRegistryEntry {
+	/** Primitive metadata */
+	meta: PrimitiveMeta;
+	/** Render function */
+	render: DemoRenderer;
+}
+/**
+* Checks if a string is a valid PrimitiveId.
+*/
+declare function isPrimitiveId(value: string): value is PrimitiveId;
+export { PrimitiveId, ThemeMethodCategory, ThemeMethodMeta, VariantMeta, PrimitiveMeta, ExampleTexts, DemoConfig, DemoRenderer, DemoRegistryEntry, isPrimitiveId };

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

@@ -0,0 +1,300 @@
+/**
+* A tree node for hierarchical data structures.
+*
+* @example
+* ```typescript
+* const tree: TreeNode = {
+*   name: "src",
+*   children: [
+*     { name: "index.ts", children: [] },
+*     { name: "utils", children: [{ name: "helpers.ts", children: [] }] },
+*   ],
+* };
+* ```
+*/
+interface TreeNode {
+	/** The name/label of this node */
+	name: string;
+	/** Child nodes (empty array for leaf nodes) */
+	children: TreeNode[];
+}
+/**
+* A collection of items, rendered as table (objects) or list (primitives).
+*
+* @example
+* ```typescript
+* // Table rendering (array of objects)
+* const users: Collection = {
+*   type: "collection",
+*   items: [{ name: "Alice", age: 30 }, { name: "Bob", age: 25 }],
+*   headers: { name: "Name", age: "Age" },
+* };
+*
+* // List rendering (array of primitives)
+* const tasks: Collection = {
+*   type: "collection",
+*   items: ["Task 1", "Task 2", "Task 3"],
+* };
+* ```
+*/
+interface Collection {
+	/** Discriminant for Collection type */
+	type: "collection";
+	/** Array of items to render */
+	items: unknown[];
+	/** Optional custom headers for table rendering */
+	headers?: Record<string, string>;
+}
+/**
+* A hierarchical tree structure.
+*
+* @example
+* ```typescript
+* const fileTree: Hierarchy = {
+*   type: "hierarchy",
+*   root: {
+*     name: "project",
+*     children: [
+*       { name: "src", children: [{ name: "index.ts", children: [] }] },
+*       { name: "package.json", children: [] },
+*     ],
+*   },
+* };
+* ```
+*/
+interface Hierarchy {
+	/** Discriminant for Hierarchy type */
+	type: "hierarchy";
+	/** Root node of the tree */
+	root: TreeNode;
+}
+/**
+* Key-value pairs for displaying configuration or metadata.
+*
+* @example
+* ```typescript
+* const config: KeyValue = {
+*   type: "keyvalue",
+*   entries: {
+*     name: "my-app",
+*     version: "1.0.0",
+*     debug: true,
+*   },
+* };
+* ```
+*/
+interface KeyValue {
+	/** Discriminant for KeyValue type */
+	type: "keyvalue";
+	/** Key-value entries to display */
+	entries: Record<string, unknown>;
+}
+/**
+* A resource with content in a specific format.
+*
+* @example
+* ```typescript
+* const jsonResource: Resource = {
+*   type: "resource",
+*   data: { name: "test", value: 42 },
+*   format: "json",
+* };
+*
+* const markdownResource: Resource = {
+*   type: "resource",
+*   data: "# Heading\n\nSome **bold** text",
+*   format: "markdown",
+* };
+* ```
+*/
+interface Resource {
+	/** Discriminant for Resource type */
+	type: "resource";
+	/** The content to render */
+	data: unknown;
+	/** Output format (defaults to "json") */
+	format?: "json" | "markdown" | "text";
+}
+/**
+* Discriminated union of all output shape types.
+*
+* Use the type guards {@link isCollection}, {@link isHierarchy},
+* {@link isKeyValue}, and {@link isResource} for type narrowing.
+*
+* @example
+* ```typescript
+* function processShape(shape: Shape) {
+*   if (isCollection(shape)) {
+*     console.log(`Collection with ${shape.items.length} items`);
+*   } else if (isHierarchy(shape)) {
+*     console.log(`Tree rooted at ${shape.root.name}`);
+*   }
+* }
+* ```
+*/
+type Shape = Collection | Hierarchy | KeyValue | Resource;
+/**
+* Options for the unified {@link render} function.
+*
+* @example
+* ```typescript
+* const options: RenderOptions = {
+*   width: 80,
+*   color: true,
+*   format: "json",
+* };
+* ```
+*/
+interface RenderOptions {
+	/** Maximum width for output (used by some renderers) */
+	width?: number;
+	/** Whether to use ANSI colors in output */
+	color?: boolean;
+	/** Force a specific output format, overriding auto-selection */
+	format?: "table" | "list" | "tree" | "json" | "text";
+}
+/**
+* Type guard for {@link Collection} shapes.
+*
+* @param shape - Shape to check
+* @returns `true` if the shape is a Collection
+*
+* @example
+* ```typescript
+* if (isCollection(shape)) {
+*   console.log(`Has ${shape.items.length} items`);
+* }
+* ```
+*/
+declare function isCollection(shape: Shape): shape is Collection;
+/**
+* Type guard for {@link Hierarchy} shapes.
+*
+* @param shape - Shape to check
+* @returns `true` if the shape is a Hierarchy
+*
+* @example
+* ```typescript
+* if (isHierarchy(shape)) {
+*   console.log(`Root: ${shape.root.name}`);
+* }
+* ```
+*/
+declare function isHierarchy(shape: Shape): shape is Hierarchy;
+/**
+* Type guard for {@link KeyValue} shapes.
+*
+* @param shape - Shape to check
+* @returns `true` if the shape is a KeyValue
+*
+* @example
+* ```typescript
+* if (isKeyValue(shape)) {
+*   console.log(`Keys: ${Object.keys(shape.entries).join(", ")}`);
+* }
+* ```
+*/
+declare function isKeyValue(shape: Shape): shape is KeyValue;
+/**
+* Type guard for {@link Resource} shapes.
+*
+* @param shape - Shape to check
+* @returns `true` if the shape is a Resource
+*
+* @example
+* ```typescript
+* if (isResource(shape)) {
+*   console.log(`Format: ${shape.format ?? "json"}`);
+* }
+* ```
+*/
+declare function isResource(shape: Shape): shape is Resource;
+/**
+* Converts a TreeNode to the Record format expected by renderTree.
+*/
+declare function treeNodeToRecord(node: TreeNode): Record<string, unknown>;
+/**
+* Checks if an item is a plain object (not null, not array, not primitive).
+*/
+declare function isPlainObject(item: unknown): item is Record<string, unknown>;
+/**
+* A function that renders a shape to a string.
+*
+* @typeParam S - The specific shape type this renderer handles
+*/
+type ShapeRenderer<S extends Shape = Shape> = (shape: S, options?: RenderOptions) => string;
+/**
+* Registers a custom renderer for a shape type.
+* Custom renderers take precedence over built-in renderers.
+*
+* @param shapeType - The shape type to register (e.g., "collection", "hierarchy")
+* @param renderer - The renderer function to use for this shape type
+*
+* @example
+* ```typescript
+* registerRenderer("collection", (shape, opts) => {
+*   return shape.items.map(item => `- ${item}`).join("\n");
+* });
+* ```
+*/
+declare function registerRenderer<S extends Shape>(shapeType: S["type"], renderer: ShapeRenderer<S>): void;
+/**
+* Removes a custom renderer, reverting to built-in behavior.
+*
+* @param shapeType - The shape type to unregister
+* @returns `true` if a renderer was removed, `false` if none existed
+*
+* @example
+* ```typescript
+* unregisterRenderer("collection"); // Reverts to built-in table/list rendering
+* ```
+*/
+declare function unregisterRenderer(shapeType: string): boolean;
+/**
+* Clears all custom renderers, reverting to built-in behavior.
+* Useful for testing to ensure clean state between tests.
+*
+* @example
+* ```typescript
+* afterEach(() => {
+*   clearRenderers();
+* });
+* ```
+*/
+declare function clearRenderers(): void;
+/**
+* Unified render function that auto-selects the appropriate renderer based on shape type.
+*
+* Auto-selection logic:
+* - **Collection**: Uses {@link renderTable} for object items, {@link renderList} for primitives
+* - **Hierarchy**: Uses {@link renderTree}
+* - **KeyValue**: Renders as formatted key-value pairs (JSON-like)
+* - **Resource**: Uses {@link renderJson}, {@link renderMarkdown}, or {@link renderText} based on format
+*
+* The `options.format` parameter can override auto-selection.
+*
+* @param shape - The shape to render
+* @param options - Rendering options
+* @returns Rendered string output
+*
+* @example
+* ```typescript
+* // Collection auto-selects table or list
+* render({ type: "collection", items: [{ name: "Alice" }] });
+* render({ type: "collection", items: ["item1", "item2"] });
+*
+* // Hierarchy uses tree rendering
+* render({ type: "hierarchy", root: { name: "src", children: [] } });
+*
+* // KeyValue renders formatted pairs
+* render({ type: "keyvalue", entries: { key: "value" } });
+*
+* // Resource respects format option
+* render({ type: "resource", data: obj, format: "json" });
+*
+* // Override with options.format
+* render({ type: "collection", items: [{ a: 1 }] }, { format: "json" });
+* ```
+*/
+declare function render(shape: Shape, options?: RenderOptions): string;
+export { TreeNode, Collection, Hierarchy, KeyValue, Resource, Shape, RenderOptions, isCollection, isHierarchy, isKeyValue, isResource, treeNodeToRecord, isPlainObject, ShapeRenderer, registerRenderer, unregisterRenderer, clearRenderers, render };

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

@@ -0,0 +1,66 @@
+import { WritableStream } from "./tui-b14ry1j1";
+/**
+* Spinner frame sets.
+*/
+declare const SPINNER_FRAMES: {
+	readonly dots: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+	readonly line: readonly ["-", "\\", "|", "/"];
+	readonly simple: readonly ["◐", "◓", "◑", "◒"];
+};
+/**
+* Available spinner styles.
+*/
+type SpinnerStyle = keyof typeof SPINNER_FRAMES;
+/**
+* Options for creating a spinner.
+*/
+interface SpinnerOptions {
+	/** Spinner style */
+	style?: SpinnerStyle;
+	/** Target stream */
+	stream?: WritableStream;
+	/** Frame interval in ms */
+	interval?: number;
+}
+/**
+* Spinner interface for animated progress indication.
+*/
+interface Spinner {
+	/** Start the spinner */
+	start(): void;
+	/** Update the spinner message */
+	update(message: string): void;
+	/** Stop with success state */
+	succeed(message?: string): void;
+	/** Stop with failure state */
+	fail(message?: string): void;
+	/** Stop the spinner */
+	stop(): void;
+}
+/**
+* Creates an animated spinner for indicating progress.
+*
+* In TTY mode, shows an animated spinner. In non-TTY mode,
+* falls back to static output.
+*
+* @param message - Initial spinner message
+* @param options - Spinner configuration
+* @returns Spinner instance
+*
+* @example
+* ```typescript
+* import { createSpinner } from "@outfitter/tui/streaming";
+*
+* const spinner = createSpinner("Installing dependencies");
+* spinner.start();
+*
+* try {
+*   await install();
+*   spinner.succeed("Dependencies installed");
+* } catch (error) {
+*   spinner.fail("Installation failed");
+* }
+* ```
+*/
+declare function createSpinner(message: string, options?: SpinnerOptions): Spinner;
+export { SpinnerStyle, SpinnerOptions, Spinner, createSpinner };

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

@@ -0,0 +1,54 @@
+/**
+* ANSI escape sequences for terminal control.
+*
+* @packageDocumentation
+*/
+/**
+* ANSI escape sequences for cursor and screen control.
+*
+* @example
+* ```typescript
+* import { ANSI } from "@outfitter/tui/streaming";
+*
+* // Move cursor up 2 lines and clear
+* process.stdout.write(ANSI.cursorUp(2) + ANSI.clearLine);
+*
+* // Hide cursor during animation
+* process.stdout.write(ANSI.hideCursor);
+* // ... do animation ...
+* process.stdout.write(ANSI.showCursor);
+* ```
+*/
+declare const ANSI: {
+	/** Move cursor up n lines */
+	readonly cursorUp: (n: number) => string;
+	/** Move cursor down n lines */
+	readonly cursorDown: (n: number) => string;
+	/** Move cursor right n columns */
+	readonly cursorRight: (n: number) => string;
+	/** Move cursor left n columns */
+	readonly cursorLeft: (n: number) => string;
+	/** Move cursor to beginning of line */
+	readonly cursorToStart: "\x1B[G";
+	/** Clear entire line */
+	readonly clearLine: "\x1B[2K";
+	/** Clear from cursor to end of screen */
+	readonly clearToEnd: "\x1B[0J";
+	/** Clear from cursor to beginning of screen */
+	readonly clearToStart: "\x1B[1J";
+	/** Clear entire screen */
+	readonly clearScreen: "\x1B[2J";
+	/** Hide cursor */
+	readonly hideCursor: "\x1B[?25l";
+	/** Show cursor */
+	readonly showCursor: "\x1B[?25h";
+	/** Save cursor position */
+	readonly saveCursor: "\x1B[s";
+	/** Restore cursor position */
+	readonly restoreCursor: "\x1B[u";
+	/** Carriage return (move to start of line) */
+	readonly carriageReturn: "\r";
+	/** New line */
+	readonly newLine: "\n";
+};
+export { ANSI };

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

@@ -0,0 +1,30 @@
+// @bun
+// packages/tui/src/render/format.ts
+function formatDuration(ms) {
+  if (ms < 1000)
+    return `${ms}ms`;
+  const seconds = Math.floor(ms / 1000) % 60;
+  const minutes = Math.floor(ms / 60000) % 60;
+  const hours = Math.floor(ms / 3600000);
+  const parts = [];
+  if (hours > 0)
+    parts.push(`${hours}h`);
+  if (minutes > 0)
+    parts.push(`${minutes}m`);
+  if (seconds > 0 || parts.length === 0)
+    parts.push(`${seconds}s`);
+  return parts.join(" ");
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let unitIndex = 0;
+  let size = bytes;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  const formatted = unitIndex === 0 ? size.toString() : size.toFixed(1).replace(/\.0$/, "");
+  return `${formatted} ${units[unitIndex]}`;
+}
+
+export { formatDuration, formatBytes };

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

@@ -0,0 +1,7 @@
+// @bun
+import {
+  init_borders
+} from "./tui-2pwhzg55.js";
+
+// packages/tui/src/borders/index.ts
+init_borders();