@outfitter/tui 0.2.0

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

@@ -0,0 +1,328 @@
+import { TreeGuideStyle } from "./tui-3dyxg62j";
+/**
+* Delimiter set with unicode and fallback representations.
+*/
+interface DelimiterSet {
+	/** Unicode character for modern terminals */
+	unicode: string;
+	/** ASCII fallback for limited terminals */
+	fallback: string;
+}
+/**
+* Available delimiter names.
+*/
+type DelimiterName = keyof typeof DELIMITERS;
+/**
+* Registry of delimiter characters with unicode and fallback support.
+*
+* @example
+* ```typescript
+* import { DELIMITERS, getDelimiter } from "@outfitter/tui/render/stack";
+*
+* // Access directly
+* console.log(DELIMITERS.bullet.unicode); // "•"
+*
+* // Or use helper
+* console.log(getDelimiter("bullet")); // "•" or "*"
+* ```
+*/
+declare const DELIMITERS: {
+	readonly space: {
+		readonly unicode: " ";
+		readonly fallback: " ";
+	};
+	readonly bullet: {
+		readonly unicode: "•";
+		readonly fallback: "*";
+	};
+	readonly dot: {
+		readonly unicode: "·";
+		readonly fallback: ".";
+	};
+	readonly pipe: {
+		readonly unicode: "│";
+		readonly fallback: "|";
+	};
+	readonly arrow: {
+		readonly unicode: "→";
+		readonly fallback: "->";
+	};
+	readonly slash: {
+		readonly unicode: "/";
+		readonly fallback: "/";
+	};
+	readonly colon: {
+		readonly unicode: ":";
+		readonly fallback: ":";
+	};
+};
+/**
+* Gets a delimiter character with automatic unicode/fallback selection.
+*
+* @param name - The delimiter name
+* @param forceUnicode - Override unicode detection
+* @returns The appropriate delimiter character
+*
+* @example
+* ```typescript
+* getDelimiter("bullet");       // "•" (in unicode terminal)
+* getDelimiter("bullet", false); // "*" (force fallback)
+* ```
+*/
+declare function getDelimiter(name: DelimiterName, forceUnicode?: boolean): string;
+/**
+* Known marker names from INDICATORS.marker.
+*/
+type MarkerName = "circleDot" | "circleOutline" | "circle" | "checkbox" | "checkboxChecked" | "pointer" | "dash";
+/**
+* Gets a marker character, either from INDICATORS or as a custom string.
+*
+* @param nameOrChar - Marker name from INDICATORS.marker or custom string
+* @param forceUnicode - Override unicode detection
+* @returns The marker character
+*
+* @example
+* ```typescript
+* getMarker("circleDot");       // "◉"
+* getMarker("circleDot", false); // "(*)"
+* getMarker("★");               // "★" (custom, returned as-is)
+* ```
+*/
+declare function getMarker(nameOrChar: MarkerName | string, forceUnicode?: boolean): string;
+/**
+* Vertical stack display modes.
+*
+* - `plain`: Simple newlines, no guides
+* - `guide`: Vertical guide continuation (│)
+* - `tree`: Tree-style with fork/end markers (├/└)
+* - `boxed`: Each item wrapped in a box
+* - `compact`: Single line per item using compact representation
+*/
+type VStackMode = "plain" | "guide" | "tree" | "boxed" | "compact";
+/**
+* Semantic states for stack items.
+* Theme maps these to visual markers.
+*/
+type ItemState = "default" | "current" | "focused" | "checked" | "disabled";
+/**
+* Theme configuration for stack rendering.
+* Maps semantic states to visual representation.
+*/
+interface StackTheme {
+	/** Map semantic states to marker names */
+	markers: Record<ItemState, MarkerName>;
+	/** Default delimiter for compact mode */
+	delimiter?: DelimiterName;
+	/** Default guide style */
+	guide?: TreeGuideStyle;
+}
+/**
+* Default theme for stack rendering.
+*/
+declare const DEFAULT_STACK_THEME: StackTheme;
+/**
+* An item in a stack with optional metadata.
+*/
+interface StackItem {
+	/** Full content (header + body lines) */
+	content: string | string[];
+	/** Compact single-line representation */
+	compact?: string;
+	/** Semantic state (resolved via theme) */
+	state?: ItemState;
+	/** Explicit marker (bypasses theme) */
+	marker?: MarkerName | string;
+	/** Style function to apply to content */
+	style?: (s: string) => string;
+}
+/**
+* A rendered block with metadata for composition.
+* Both Box and StackBox satisfy this interface.
+*/
+interface Renderable {
+	/** Rendered string representation */
+	readonly output: string;
+	/** Width in characters */
+	readonly width: number;
+	/** Height in lines */
+	readonly height: number;
+}
+/**
+* A rendered stack with metadata for composition.
+* Alias for Renderable (for semantic clarity when returning from stack functions).
+*/
+type StackBox = Renderable;
+/**
+* Type guard to check if a value is a Renderable (Box or StackBox).
+*/
+declare function isRenderable(value: unknown): value is Renderable;
+/**
+* Options for horizontal stack.
+*/
+interface HStackOptions {
+	/** Delimiter between items (name or custom string) */
+	delimiter?: DelimiterName | string;
+	/** Gap (spaces) around delimiter */
+	gap?: number;
+	/** Vertical alignment for multi-line items */
+	align?: "top" | "center" | "bottom";
+}
+/**
+* Options for vertical stack.
+*/
+interface VStackOptions {
+	/** Display mode */
+	mode?: VStackMode;
+	/** Gap (lines) between items */
+	gap?: number;
+	/** Theme for marker resolution */
+	theme?: Partial<StackTheme>;
+	/** Shorthand for theme.guide */
+	guide?: TreeGuideStyle;
+}
+/**
+* Input type for stack functions.
+* Accepts strings, StackItems, or Renderables (Box/StackBox).
+*/
+type StackInput = string | StackItem | Renderable;
+/**
+* Joins items horizontally with a delimiter.
+*
+* @param items - Items to join (strings or StackItems)
+* @param options - Configuration options
+* @returns Joined string
+*
+* @example
+* ```typescript
+* // Simple delimiter
+* hstack(["a", "b", "c"], { delimiter: "bullet", gap: 1 });
+* // → "a • b • c"
+*
+* // Multi-line with alignment
+* hstack(["Line1\nLine2", "Single"], { delimiter: "pipe", align: "center" });
+* ```
+*/
+declare function hstack(items: StackInput[], options?: HStackOptions): string;
+/**
+* Creates a horizontal stack with metadata for composition.
+*
+* @param items - Items to join
+* @param options - Configuration options
+* @returns StackBox with output, width, and height
+*/
+declare function createHStack(items: StackInput[], options?: HStackOptions): StackBox;
+/**
+* Creates a stack item with header and optional body.
+*
+* @param header - Header line
+* @param body - Optional body lines
+* @param options - Item options (state, marker, compact, style)
+* @returns StackItem
+*
+* @example
+* ```typescript
+* vstackItem("feature/auth", ["PR #190 (Draft)", "2 hours ago"], {
+*   state: "current",
+*   compact: "feature/auth • Draft • 2h ago"
+* });
+* ```
+*/
+declare function vstackItem(header: string, body?: string[], options?: {
+	state?: ItemState;
+	marker?: MarkerName | string;
+	compact?: string;
+	style?: (s: string) => string;
+}): StackItem;
+/**
+* Stacks items vertically with configurable display mode.
+*
+* @param items - Items to stack (strings or StackItems)
+* @param options - Configuration options
+* @returns Formatted string
+*
+* @example
+* ```typescript
+* // Guide mode (gt log style)
+* vstack([
+*   vstackItem("feature/auth", ["PR #190"], { state: "current" }),
+*   vstackItem("feature/api", ["PR #189"]),
+* ], { mode: "guide" });
+* // → ◉ feature/auth
+* //   │ PR #190
+* //   │
+* //   ○ feature/api
+* //   │ PR #189
+*
+* // Compact mode
+* vstack(items, { mode: "compact" });
+* // → ◉ feature/auth • Draft • 2h ago
+* //   ○ feature/api • 1d ago
+* ```
+*/
+declare function vstack(items: StackInput[], options?: VStackOptions): string;
+/**
+* Creates a vertical stack with metadata for composition.
+*
+* @param items - Items to stack
+* @param options - Configuration options
+* @returns StackBox with output, width, and height
+*/
+declare function createVStack(items: StackInput[], options?: VStackOptions): StackBox;
+/**
+* Options for boxify helper.
+*/
+interface BoxifyOptions {
+	/** Box title */
+	title?: string;
+	/** Border style */
+	border?: "single" | "double" | "rounded" | "heavy" | "none";
+	/** Padding inside the box */
+	padding?: number;
+}
+/**
+* Wraps content in a box for visual grouping.
+*
+* Convenience wrapper around createBox that accepts any Renderable,
+* string, or string array.
+*
+* @param content - Content to wrap (Renderable, string, or string[])
+* @param options - Box options (title, border, padding)
+* @returns Renderable box that can be used in stacks or nested
+*
+* @example
+* ```typescript
+* // Boxify a stack
+* const stack = createVStack([...], { mode: "guide" });
+* const boxed = boxify(stack, { title: "Branches", border: "rounded" });
+*
+* // Boxify plain text
+* const box = boxify("Hello World", { border: "double" });
+*
+* // Use in composition
+* hstack([boxify(stack1), boxify(stack2)], { gap: 2 });
+* ```
+*/
+declare function boxify(content: Renderable | string | string[], options?: BoxifyOptions): Renderable;
+/**
+* Extracts the raw output string from a Renderable.
+*
+* Useful when you need the string representation without the metadata,
+* or when passing to functions that only accept strings.
+*
+* @param content - Renderable or string
+* @returns The output string
+*
+* @example
+* ```typescript
+* const stack = createVStack([...], { mode: "guide" });
+* const raw = unbox(stack); // Just the string, no metadata
+*
+* // Useful for logging or string manipulation
+* console.log(unbox(boxedContent));
+*
+* // Pass-through for strings
+* unbox("already a string"); // Returns "already a string"
+* ```
+*/
+declare function unbox(content: Renderable | string): string;
+export { DelimiterSet, DelimiterName, DELIMITERS, getDelimiter, MarkerName, getMarker, VStackMode, ItemState, StackTheme, DEFAULT_STACK_THEME, StackItem, Renderable, StackBox, isRenderable, HStackOptions, VStackOptions, StackInput, hstack, createHStack, vstackItem, vstack, createVStack, BoxifyOptions, boxify, unbox };

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

@@ -0,0 +1,223 @@
+import { BorderStyle } from "./tui-1qh888th";
+/**
+* Text alignment options for box content.
+*/
+type BoxAlign = "left" | "center" | "right";
+/**
+* Options for customizing box rendering.
+*
+* @example
+* ```typescript
+* // Box with title and rounded corners
+* renderBox("Content", {
+*   title: "Status",
+*   border: "rounded",
+*   padding: 1,
+* });
+*
+* // Fixed-width centered box
+* renderBox("Centered", {
+*   width: 40,
+*   align: "center",
+* });
+* ```
+*/
+/**
+* Spacing configuration for individual sides.
+*/
+interface BoxSpacing {
+	top?: number;
+	right?: number;
+	bottom?: number;
+	left?: number;
+}
+/**
+* Border visibility configuration for individual sides.
+*/
+interface BoxBorders {
+	top?: boolean;
+	right?: boolean;
+	bottom?: boolean;
+	left?: boolean;
+}
+interface BoxOptions {
+	/**
+	* Border style to use.
+	* @default "single"
+	*/
+	border?: BorderStyle;
+	/**
+	* Control which borders to render.
+	* @default { top: true, right: true, bottom: true, left: true }
+	*/
+	borders?: BoxBorders;
+	/**
+	* Internal padding (spaces between border and content).
+	* Can be a single number for all sides or an object for individual sides.
+	* @default 1
+	*/
+	padding?: number | BoxSpacing;
+	/**
+	* External margin (spacing outside the box).
+	* Can be a single number for all sides or an object for individual sides.
+	*/
+	margin?: number | BoxSpacing;
+	/**
+	* Fixed width for the box. If not specified, auto-fits to content.
+	*/
+	width?: number;
+	/**
+	* Optional title to display in the top border.
+	*/
+	title?: string;
+	/**
+	* Content alignment within the box.
+	* @default "left"
+	*/
+	align?: BoxAlign;
+	/**
+	* Content sections separated by internal dividers.
+	* Each section can be a string or string[].
+	* When provided, takes precedence over the content parameter.
+	*
+	* @example
+	* ```typescript
+	* renderBox("", {
+	*   sections: [
+	*     "Header",
+	*     ["Line 1", "Line 2"],
+	*     "Footer"
+	*   ],
+	*   border: "single"
+	* });
+	* // ┌─────────────────┐
+	* // │ Header          │
+	* // ├─────────────────┤
+	* // │ Line 1          │
+	* // │ Line 2          │
+	* // ├─────────────────┤
+	* // │ Footer          │
+	* // └─────────────────┘
+	* ```
+	*/
+	sections?: Array<string | string[]>;
+}
+/**
+* A rendered box with metadata for composition.
+*/
+interface Box {
+	/** Rendered string representation */
+	readonly output: string;
+	/** Width in characters */
+	readonly width: number;
+	/** Height in lines */
+	readonly height: number;
+}
+/**
+* Content that can be rendered inside a box.
+* - string: Plain text content
+* - string[]: Multi-line content
+* - Box: Nested box (rendered string with metadata)
+*/
+type BoxContent = string | string[] | Box;
+/**
+* Normalized spacing with all four sides defined.
+*/
+interface NormalizedSpacing {
+	top: number;
+	right: number;
+	bottom: number;
+	left: number;
+}
+/**
+* Normalized borders with all four sides defined.
+*/
+interface NormalizedBorders {
+	top: boolean;
+	right: boolean;
+	bottom: boolean;
+	left: boolean;
+}
+/**
+* Normalizes padding input to have all four sides.
+* For backward compatibility, when padding is a number it only applies to horizontal (left/right).
+* When padding is an object, all sides can be specified.
+*/
+declare function normalizePadding(padding: number | BoxSpacing | undefined, defaultValue: number): NormalizedSpacing;
+/**
+* Normalizes margin input to have all four sides.
+* When margin is a number, it applies to all sides.
+*/
+declare function normalizeMargin(margin: number | BoxSpacing | undefined, defaultValue: number): NormalizedSpacing;
+/**
+* Normalizes borders input to have all four sides.
+*/
+declare function normalizeBorders(borders: BoxBorders | undefined): NormalizedBorders;
+/**
+* Renders content within a bordered panel.
+*
+* Creates a box with Unicode borders around the content. Supports multiple
+* border styles, titles, padding, and alignment options.
+*
+* @param content - The content to render (string or array of strings)
+* @param options - Optional configuration for border style, padding, etc.
+* @returns Formatted box string
+*
+* @example
+* ```typescript
+* // Simple box
+* console.log(renderBox("Hello, world!"));
+* // ┌───────────────┐
+* // │ Hello, world! │
+* // └───────────────┘
+*
+* // Box with title
+* console.log(renderBox("All systems go", { title: "Status" }));
+* // ┌─ Status ──────┐
+* // │ All systems go │
+* // └────────────────┘
+*
+* // Rounded box with padding
+* console.log(renderBox(["Line 1", "Line 2"], {
+*   border: "rounded",
+*   padding: 2,
+* }));
+* // ╭──────────────╮
+* // │              │
+* // │  Line 1      │
+* // │  Line 2      │
+* // │              │
+* // ╰──────────────╯
+* ```
+*/
+declare function renderBox(content: string | string[], options?: BoxOptions): string;
+/**
+* Creates a Box object that can be composed with other boxes.
+*
+* Unlike `renderBox` which returns a string, `createBox` returns a Box object
+* with metadata (width, height) that enables nested composition.
+*
+* @param content - The content to render (string, string[], Box, or array of mixed)
+* @param options - Optional configuration for border style, padding, etc.
+* @returns Box object with output, width, and height
+*
+* @example
+* ```typescript
+* // Simple box
+* const box = createBox("Hello");
+* console.log(box.output);
+* console.log(`Width: ${box.width}, Height: ${box.height}`);
+*
+* // Nested boxes
+* const inner = createBox("Inner", { border: "rounded" });
+* const outer = createBox(inner, { border: "double", title: "Container" });
+* console.log(outer.output);
+* // ╔═ Container ═══════════════╗
+* // ║ ╭───────────────────────╮ ║
+* // ║ │ Inner                 │ ║
+* // ║ ╰───────────────────────╯ ║
+* // ╚═══════════════════════════╝
+* ```
+*/
+declare function createBox(content: BoxContent | BoxContent[], options?: BoxOptions): Box;
+export { BoxAlign, BoxSpacing, BoxBorders, BoxOptions, Box, BoxContent, NormalizedSpacing, NormalizedBorders, normalizePadding, normalizeMargin, normalizeBorders, renderBox, createBox };

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

@@ -0,0 +1,20 @@
+// @bun
+import {
+  getIndicator,
+  isUnicodeSupported
+} from "./tui-pdwbbzwr.js";
+
+// packages/tui/src/theme/resolve.ts
+function resolveGlyph(glyph, forceUnicode) {
+  const useUnicode = forceUnicode ?? isUnicodeSupported();
+  return useUnicode ? glyph.unicode : glyph.fallback;
+}
+function resolveStateMarker(theme, state, forceUnicode) {
+  const markerSpec = theme.markers[state] ?? theme.markers.default;
+  if (markerSpec.type === "indicator") {
+    return getIndicator(markerSpec.category, markerSpec.name, forceUnicode);
+  }
+  return resolveGlyph(markerSpec.glyph, forceUnicode);
+}
+
+export { resolveGlyph, resolveStateMarker };

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

@@ -0,0 +1,20 @@
+// @bun
+import {
+  createCancelledError
+} from "./tui-kcxv8txp.js";
+
+// packages/tui/src/prompt/group.ts
+import { Result as R } from "better-result";
+async function promptGroup(steps) {
+  const result = {};
+  for (const [key, step] of Object.entries(steps)) {
+    const stepResult = await step();
+    if (stepResult.isErr()) {
+      return R.err(createCancelledError(stepResult.error.message));
+    }
+    result[key] = stepResult.value;
+  }
+  return R.ok(result);
+}
+
+export { promptGroup };

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

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

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

@@ -0,0 +1,67 @@
+// @bun
+import {
+  createCancelledError
+} from "./tui-kcxv8txp.js";
+
+// packages/tui/src/prompt/select.ts
+import { isCancel, multiselect, select } from "@clack/prompts";
+import { Result } from "better-result";
+async function promptSelect(options) {
+  const clackOptions = options.options.map((opt) => {
+    const mapped = {
+      value: opt.value,
+      label: opt.label
+    };
+    if (opt.hint !== undefined) {
+      mapped.hint = opt.hint;
+    }
+    return mapped;
+  });
+  const selectOptions = {
+    message: options.message,
+    options: clackOptions
+  };
+  if (options.initialValue !== undefined) {
+    selectOptions.initialValue = options.initialValue;
+  }
+  if (options.pageSize !== undefined) {
+    selectOptions.maxItems = options.pageSize;
+  }
+  const result = await select(selectOptions);
+  if (isCancel(result)) {
+    return Result.err(createCancelledError());
+  }
+  return Result.ok(result);
+}
+async function promptMultiSelect(options) {
+  const clackOptions = options.options.map((opt) => {
+    const mapped = {
+      value: opt.value,
+      label: opt.label
+    };
+    if (opt.hint !== undefined) {
+      mapped.hint = opt.hint;
+    }
+    return mapped;
+  });
+  const multiselectOptions = {
+    message: options.message,
+    options: clackOptions
+  };
+  if (options.initialValues !== undefined) {
+    multiselectOptions.initialValues = options.initialValues;
+  }
+  if (options.required !== undefined) {
+    multiselectOptions.required = options.required;
+  }
+  if (options.pageSize !== undefined) {
+    multiselectOptions.maxItems = options.pageSize;
+  }
+  const result = await multiselect(multiselectOptions);
+  if (isCancel(result)) {
+    return Result.err(createCancelledError());
+  }
+  return Result.ok(result);
+}
+
+export { promptSelect, promptMultiSelect };