@outfitter/cli 0.1.0-rc.2 → 0.1.0

package/dist/shared/@outfitter/cli-1bghjef6.js

@@ -0,0 +1,352 @@
+// @bun
+import {
+  TREE_GUIDES
+} from "./cli-b5c2k0d7.js";
+import {
+  getIndicator,
+  isUnicodeSupported
+} from "./cli-p1m5dhrs.js";
+import {
+  joinHorizontal,
+  joinVertical
+} from "./cli-671sxkhj.js";
+import {
+  exports_box,
+  init_box,
+  renderBox
+} from "./cli-vp88gxev.js";
+import {
+  getStringWidth,
+  init_text
+} from "./cli-jjemfdta.js";
+import {
+  __toCommonJS
+} from "./cli-v1tzwxkt.js";
+
+// packages/cli/src/render/stack.ts
+init_box();
+init_text();
+var DELIMITERS = {
+  space: { unicode: " ", fallback: " " },
+  bullet: { unicode: "\u2022", fallback: "*" },
+  dot: { unicode: "\xB7", fallback: "." },
+  pipe: { unicode: "\u2502", fallback: "|" },
+  arrow: { unicode: "\u2192", fallback: "->" },
+  slash: { unicode: "/", fallback: "/" },
+  colon: { unicode: ":", fallback: ":" }
+};
+function getDelimiter(name, forceUnicode) {
+  const delimiter = DELIMITERS[name];
+  const useUnicode = forceUnicode ?? isUnicodeSupported();
+  return useUnicode ? delimiter.unicode : delimiter.fallback;
+}
+function getMarker(nameOrChar, forceUnicode) {
+  const knownMarkers = [
+    "circleDot",
+    "circleOutline",
+    "circle",
+    "checkbox",
+    "checkboxChecked",
+    "pointer",
+    "dash"
+  ];
+  if (knownMarkers.includes(nameOrChar)) {
+    return getIndicator("marker", nameOrChar, forceUnicode);
+  }
+  return nameOrChar;
+}
+var DEFAULT_STACK_THEME = {
+  markers: {
+    default: "circleOutline",
+    current: "circleDot",
+    focused: "pointer",
+    checked: "checkboxChecked",
+    disabled: "dash"
+  },
+  delimiter: "bullet",
+  guide: "single"
+};
+function isRenderable(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 isDelimiterName(value) {
+  return value in DELIMITERS;
+}
+function resolveDelimiter(delimiter) {
+  if (delimiter === undefined) {
+    return getDelimiter("space");
+  }
+  if (isDelimiterName(delimiter)) {
+    return getDelimiter(delimiter);
+  }
+  return delimiter;
+}
+function normalizeItem(item) {
+  if (typeof item === "string") {
+    return { content: item };
+  }
+  if (isRenderable(item)) {
+    return { content: item.output };
+  }
+  return item;
+}
+function shouldShowMarker(item) {
+  return item.state !== undefined || item.marker !== undefined;
+}
+function resolveMarker(item, theme) {
+  if (!shouldShowMarker(item)) {
+    return { marker: "", show: false };
+  }
+  if (item.marker !== undefined) {
+    return { marker: getMarker(item.marker), show: true };
+  }
+  const state = item.state ?? "default";
+  const markerName = theme.markers[state];
+  return { marker: getMarker(markerName), show: true };
+}
+function getContentLines(content) {
+  if (typeof content === "string") {
+    return content.split(`
+`);
+  }
+  return content;
+}
+function applyStyle(content, style) {
+  return style ? style(content) : content;
+}
+function hstack(items, options) {
+  if (items.length === 0)
+    return "";
+  const normalizedItems = items.map(normalizeItem);
+  const delimiter = resolveDelimiter(options?.delimiter);
+  const gap = options?.gap ?? 0;
+  const align = options?.align ?? "top";
+  const gapStr = " ".repeat(gap);
+  const fullDelimiter = `${gapStr}${delimiter}${gapStr}`;
+  const contentStrings = normalizedItems.map((item) => {
+    const lines = getContentLines(item.content);
+    const styledLines = lines.map((line) => applyStyle(line, item.style));
+    return styledLines.join(`
+`);
+  });
+  const isMultiLine = contentStrings.some((s) => s.includes(`
+`));
+  if (!isMultiLine) {
+    return contentStrings.join(fullDelimiter);
+  }
+  const blocks = contentStrings.map((content, idx) => {
+    if (idx === contentStrings.length - 1) {
+      return content;
+    }
+    const lines = content.split(`
+`);
+    return lines.map((line) => line + fullDelimiter).join(`
+`);
+  });
+  return joinHorizontal(blocks, { gap: 0, align });
+}
+function createHStack(items, options) {
+  const output = hstack(items, options);
+  const lines = output.split(`
+`);
+  const width = Math.max(...lines.map(getStringWidth));
+  return {
+    output,
+    width,
+    height: lines.length
+  };
+}
+function vstackItem(header, body, options) {
+  const content = body && body.length > 0 ? [header, ...body] : [header];
+  const result = {
+    content,
+    state: options?.state ?? "default"
+  };
+  if (options?.marker !== undefined) {
+    result.marker = options.marker;
+  }
+  if (options?.compact !== undefined) {
+    result.compact = options.compact;
+  }
+  if (options?.style !== undefined) {
+    result.style = options.style;
+  }
+  return result;
+}
+var GUIDE_CHARS = {
+  single: "\u2502",
+  heavy: "\u2503",
+  double: "\u2551",
+  rounded: "\u2502"
+};
+function renderPlainMode(items, theme, gap) {
+  const lines = [];
+  for (const item of items) {
+    const { marker, show } = resolveMarker(item, theme);
+    const contentLines = getContentLines(item.content);
+    const prefix = show ? `${marker} ` : "";
+    const firstLine = contentLines[0];
+    if (firstLine !== undefined) {
+      const styled = applyStyle(firstLine, item.style);
+      lines.push(`${prefix}${styled}`);
+    }
+    const indent = show ? "  " : "";
+    for (let i = 1;i < contentLines.length; i++) {
+      const line = contentLines[i];
+      if (line !== undefined) {
+        const styled = applyStyle(line, item.style);
+        lines.push(`${indent}${styled}`);
+      }
+    }
+  }
+  return joinVertical(lines, { gap });
+}
+function renderGuideMode(items, theme, guideStyle) {
+  const lines = [];
+  const guideChar = GUIDE_CHARS[guideStyle];
+  for (let itemIdx = 0;itemIdx < items.length; itemIdx++) {
+    const item = items[itemIdx];
+    if (!item)
+      continue;
+    const { marker, show } = resolveMarker(item, theme);
+    const contentLines = getContentLines(item.content);
+    const isLastItem = itemIdx === items.length - 1;
+    const displayMarker = show ? marker : getMarker(theme.markers.default);
+    const firstLine = contentLines[0];
+    if (firstLine !== undefined) {
+      const styled = applyStyle(firstLine, item.style);
+      lines.push(`${displayMarker} ${styled}`);
+    }
+    for (let i = 1;i < contentLines.length; i++) {
+      const line = contentLines[i];
+      if (line !== undefined) {
+        const styled = applyStyle(line, item.style);
+        lines.push(`${guideChar} ${styled}`);
+      }
+    }
+    if (!isLastItem) {
+      lines.push(guideChar);
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderTreeMode(items, guideStyle) {
+  const lines = [];
+  const guides = TREE_GUIDES[guideStyle];
+  for (let itemIdx = 0;itemIdx < items.length; itemIdx++) {
+    const item = items[itemIdx];
+    if (!item)
+      continue;
+    const contentLines = getContentLines(item.content);
+    const isLastItem = itemIdx === items.length - 1;
+    const connector = isLastItem ? guides.end : guides.fork;
+    const continuation = isLastItem ? "    " : guides.vertical;
+    const firstLine = contentLines[0];
+    if (firstLine !== undefined) {
+      const styled = applyStyle(firstLine, item.style);
+      lines.push(`${connector}${styled}`);
+    }
+    for (let i = 1;i < contentLines.length; i++) {
+      const line = contentLines[i];
+      if (line !== undefined) {
+        const styled = applyStyle(line, item.style);
+        lines.push(`${continuation}${styled}`);
+      }
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderBoxedMode(items, gap) {
+  const boxes = [];
+  for (const item of items) {
+    const contentLines = getContentLines(item.content);
+    const styled = contentLines.map((line) => applyStyle(line, item.style));
+    boxes.push(renderBox(styled));
+  }
+  return joinVertical(boxes, { gap });
+}
+function renderCompactMode(items, theme) {
+  const lines = [];
+  for (const item of items) {
+    const { marker, show } = resolveMarker(item, theme);
+    const displayMarker = show ? marker : getMarker(theme.markers.default);
+    let displayText;
+    if (item.compact) {
+      displayText = item.compact;
+    } else {
+      const contentLines = getContentLines(item.content);
+      displayText = contentLines[0] ?? "";
+    }
+    const styled = applyStyle(displayText, item.style);
+    lines.push(`${displayMarker} ${styled}`);
+  }
+  return lines.join(`
+`);
+}
+function vstack(items, options) {
+  if (items.length === 0)
+    return "";
+  const normalizedItems = items.map(normalizeItem);
+  const mode = options?.mode ?? "guide";
+  const gap = options?.gap ?? 0;
+  const theme = {
+    ...DEFAULT_STACK_THEME,
+    ...options?.theme,
+    markers: {
+      ...DEFAULT_STACK_THEME.markers,
+      ...options?.theme?.markers
+    }
+  };
+  const guideStyle = options?.guide ?? theme.guide ?? "single";
+  switch (mode) {
+    case "plain":
+      return renderPlainMode(normalizedItems, theme, gap);
+    case "guide":
+      return renderGuideMode(normalizedItems, theme, guideStyle);
+    case "tree":
+      return renderTreeMode(normalizedItems, guideStyle);
+    case "boxed":
+      return renderBoxedMode(normalizedItems, gap);
+    case "compact":
+      return renderCompactMode(normalizedItems, theme);
+    default: {
+      const _exhaustive = mode;
+      return _exhaustive;
+    }
+  }
+}
+function createVStack(items, options) {
+  const output = vstack(items, options);
+  const lines = output.split(`
+`);
+  const width = Math.max(...lines.map(getStringWidth), 0);
+  return {
+    output,
+    width,
+    height: lines.length
+  };
+}
+function boxify(content, options) {
+  const { createBox: makeBox } = (init_box(), __toCommonJS(exports_box));
+  const boxContent = isRenderable(content) ? content.output : content;
+  const boxOptions = {
+    border: options?.border ?? "single"
+  };
+  if (options?.title !== undefined) {
+    boxOptions.title = options.title;
+  }
+  if (options?.padding !== undefined) {
+    boxOptions.padding = options.padding;
+  }
+  return makeBox(boxContent, boxOptions);
+}
+function unbox(content) {
+  if (isRenderable(content)) {
+    return content.output;
+  }
+  return content;
+}
+
+export { DELIMITERS, getDelimiter, getMarker, DEFAULT_STACK_THEME, isRenderable, hstack, createHStack, vstackItem, vstack, createVStack, boxify, unbox };

package/dist/shared/@outfitter/cli-1kwbnt86.d.ts

@@ -0,0 +1,45 @@
+import { WidthMode } from "./cli-2g8bx1aq";
+/**
+* Width mode for separators.
+*
+* Separators only support "text", "full", and numeric widths.
+* Container-relative modes require context, which separators don't use.
+*/
+type SeparatorWidthMode = Extract<WidthMode, "text" | "full" | number>;
+/**
+* Separator style for dividers.
+* Single characters repeat to fill width.
+* Two-character patterns (like "- ") alternate to create dashed effect.
+*/
+type DividerStyle = "─" | "━" | "═" | "- " | "· ";
+/**
+* Options for rendering a separator.
+*/
+interface SeparatorOptions {
+	/** Separator style (default: "─") */
+	style?: DividerStyle;
+	/** Width mode (default: 40) */
+	width?: SeparatorWidthMode;
+}
+/**
+* Renders a horizontal separator line.
+*
+* @param options - Rendering options
+* @returns Formatted separator string
+*
+* @example
+* ```typescript
+* import { renderSeparator } from "@outfitter/cli/render";
+*
+* console.log(renderSeparator());
+* // ────────────────────────────────────────
+*
+* console.log(renderSeparator({ style: "━", width: 20 }));
+* // ━━━━━━━━━━━━━━━━━━━━
+*
+* console.log(renderSeparator({ style: "- ", width: 20 }));
+* // - - - - - - - - - -
+* ```
+*/
+declare function renderSeparator(options?: SeparatorOptions): string;
+export { DividerStyle, SeparatorOptions, renderSeparator };

package/dist/shared/@outfitter/cli-2g8bx1aq.d.ts

@@ -0,0 +1,50 @@
+/**
+* Shared types for render utilities.
+*
+* @packageDocumentation
+*/
+/**
+* Width mode for layout calculations.
+*
+* - `"text"` - Fit to text content (returns 0 to indicate no width constraint)
+* - `"full"` - Full terminal width
+* - `"container"` - Available container width (requires LayoutContext)
+* - `number` - Fixed character width
+* - `"${number}%"` - Percentage of container/terminal width
+*
+* @example
+* ```typescript
+* import { resolveWidth } from "@outfitter/cli/render";
+*
+* resolveWidth("full");        // → terminal width (e.g., 120)
+* resolveWidth(50);            // → 50
+* resolveWidth("50%");         // → half of terminal width
+* resolveWidth("container", ctx);  // → context width
+* ```
+*/
+type WidthMode = "text" | "full" | "container" | number | `${number}%`;
+/**
+* Layout context for container-aware width calculations.
+*
+* Provides width information to nested components so they can size
+* themselves relative to their container. Create contexts with
+* `createLayoutContext()` and pass them through component hierarchies.
+*
+* @example
+* ```typescript
+* import { createLayoutContext, resolveWidth } from "@outfitter/cli/render";
+*
+* const outerCtx = createLayoutContext({ width: 80, padding: 1 });
+* // outerCtx.width = 76 (80 - 4 overhead)
+*
+* const innerWidth = resolveWidth("50%", outerCtx);
+* // innerWidth = 38 (50% of 76)
+* ```
+*/
+interface LayoutContext {
+	/** Available content width in characters */
+	readonly width: number;
+	/** Parent context for chained calculations */
+	readonly parent?: LayoutContext;
+}
+export { WidthMode, LayoutContext };

package/dist/shared/@outfitter/cli-34fqr7bp.js

@@ -0,0 +1,37 @@
+// @bun
+import {
+  renderHeading
+} from "./cli-xvqtqjxk.js";
+import {
+  joinVertical
+} from "./cli-671sxkhj.js";
+
+// packages/cli/src/demo/section.ts
+function demoSection(title, options) {
+  return renderHeading(title, {
+    separator: options?.separator ?? "\u2500",
+    case: options?.case ?? "title"
+  });
+}
+function demoSubsection(title, options) {
+  return renderHeading(title, {
+    separator: options?.separator ?? "\u2500",
+    case: options?.case ?? "title"
+  });
+}
+function codeBlock(lines, show = true) {
+  if (!show)
+    return [];
+  return lines;
+}
+function description(text, theme, show = true) {
+  if (!show)
+    return [];
+  return [theme.muted(text)];
+}
+function demoContent(blocks, gap = 1) {
+  const filtered = blocks.filter((b) => b !== "");
+  return joinVertical(filtered, { gap });
+}
+
+export { demoSection, demoSubsection, codeBlock, description, demoContent };

package/dist/shared/@outfitter/cli-3b7ed3rm.d.ts

@@ -0,0 +1,97 @@
+/**
+* Tree rendering utilities.
+*
+* Renders hierarchical data as ASCII trees with box-drawing characters.
+*
+* @packageDocumentation
+*/
+/**
+* Available tree guide styles.
+*
+* - `single`: Standard Unicode box-drawing (default)
+* - `heavy`: Thick/bold box-drawing characters
+* - `double`: Double-line box-drawing characters
+* - `rounded`: Rounded corners (╰ instead of └)
+*/
+type TreeGuideStyle = "single" | "heavy" | "double" | "rounded";
+/**
+* Tree guide character sets for different visual styles.
+*/
+declare const TREE_GUIDES: Record<TreeGuideStyle, {
+	vertical: string;
+	fork: string;
+	end: string;
+}>;
+/**
+* Options for customizing tree rendering.
+*/
+interface TreeOptions {
+	/**
+	* Guide style for tree branches.
+	* @default "single"
+	*/
+	guide?: TreeGuideStyle;
+	/**
+	* Maximum depth to render (1 = root children only).
+	* @default undefined (unlimited)
+	*/
+	maxDepth?: number;
+	/**
+	* Custom function to render node labels.
+	* Receives the key, value, and current depth.
+	*
+	* @example
+	* ```typescript
+	* renderLabel: (key, value, depth) => {
+	*   if (value && typeof value === "object") {
+	*     return `📁 ${key}/`;
+	*   }
+	*   return `📄 ${key}`;
+	* }
+	* ```
+	*/
+	renderLabel?: (key: string, value: unknown, depth: number) => string;
+}
+/**
+* Renders hierarchical data as a tree with unicode box-drawing characters.
+*
+* Uses unicode characters for tree structure.
+* Nested objects are rendered as child nodes; leaf values (null, primitives)
+* are rendered as terminal nodes.
+*
+* @param tree - Hierarchical object to render
+* @param options - Customization options
+* @returns Formatted tree string with box-drawing characters
+*
+* @example
+* ```typescript
+* const tree = {
+*   src: {
+*     components: {
+*       Button: null,
+*       Input: null,
+*     },
+*     utils: null,
+*   },
+*   tests: null,
+* };
+*
+* console.log(renderTree(tree));
+* // ├── src
+* // │   ├── components
+* // │   │   ├── Button
+* // │   │   └── Input
+* // │   └── utils
+* // └── tests
+*
+* console.log(renderTree(tree, { guide: "rounded" }));
+* // ├── src
+* // │   ├── components
+* // │   │   ├── Button
+* // │   │   ╰── Input
+* // │   ╰── utils
+* // ╰── tests
+* ```
+*/
+declare function renderTree(tree: Record<string, unknown>, options?: TreeOptions): string;
+export { TreeGuideStyle, TREE_GUIDES, TreeOptions, renderTree };

package/dist/shared/@outfitter/cli-3dxmmy4c.d.ts

@@ -0,0 +1,20 @@
+import { VisualTheme } from "./cli-s0kkx9m1";
+/**
+* Default visual theme.
+*
+* Features:
+* - Single-line box-drawing borders (┌─┐)
+* - Standard status indicators
+* - Bullet delimiters
+* - Dots spinner
+*
+* @example
+* ```typescript
+* import { defaultTheme } from "@outfitter/cli/theme/presets";
+*
+* // Use default styling
+* const box = renderBox("Hello", { border: defaultTheme.border });
+* ```
+*/
+declare const defaultTheme: VisualTheme;
+export { defaultTheme };

package/dist/shared/@outfitter/cli-3f12z5kf.d.ts

@@ -0,0 +1,83 @@
+import { Validator } from "./cli-vstbkzky";
+import { Result } from "better-result";
+/**
+* Error returned when user cancels a prompt.
+*/
+interface CancelledError {
+	type: "cancelled";
+	message: string;
+}
+/**
+* Creates a cancelled error.
+*/
+declare function createCancelledError(message?: string): CancelledError;
+/**
+* Options for text prompts.
+*/
+interface TextPromptOptions {
+	/** Prompt message to display */
+	message: string;
+	/** Placeholder text */
+	placeholder?: string;
+	/** Default value */
+	defaultValue?: string;
+	/** Validation function */
+	validate?: Validator;
+}
+/**
+* Options for password prompts.
+*/
+interface PasswordPromptOptions {
+	/** Prompt message to display */
+	message: string;
+	/** Validation function */
+	validate?: Validator;
+	/** Mask character (default: •) */
+	mask?: string;
+}
+/**
+* Options for select prompts.
+*/
+interface SelectPromptOptions<T> {
+	/** Prompt message to display */
+	message: string;
+	/** Available options */
+	options: Array<{
+		value: T;
+		label: string;
+		hint?: string;
+	}>;
+	/** Initial selected index */
+	initialValue?: T;
+}
+/**
+* Options for multi-select prompts.
+*/
+interface MultiSelectPromptOptions<T> {
+	/** Prompt message to display */
+	message: string;
+	/** Available options */
+	options: Array<{
+		value: T;
+		label: string;
+		hint?: string;
+	}>;
+	/** Initially selected values */
+	initialValues?: T[];
+	/** Require at least one selection */
+	required?: boolean;
+}
+/**
+* Options for confirm prompts.
+*/
+interface ConfirmPromptOptions {
+	/** Prompt message to display */
+	message: string;
+	/** Initial value */
+	initialValue?: boolean;
+}
+/**
+* Type alias for prompt results.
+*/
+type PromptResult<T> = Promise<Result<T, CancelledError>>;
+export { CancelledError, createCancelledError, TextPromptOptions, PasswordPromptOptions, SelectPromptOptions, MultiSelectPromptOptions, ConfirmPromptOptions, PromptResult };