@pablozaiden/terminatui 0.2.0 → 0.3.0-beta-1

package/src/__tests__/tui.test.ts

@@ -1,26 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import {
-    KeyboardPriority,
-} from "../tui/index.ts";
-
-describe("TUI", () => {
-    describe("KeyboardPriority", () => {
-        test("Modal has highest priority", () => {
-            expect(KeyboardPriority.Modal).toBe(100);
-        });
-
-        test("Focused has medium priority", () => {
-            expect(KeyboardPriority.Focused).toBe(50);
-        });
-
-        test("Global has lowest priority", () => {
-            expect(KeyboardPriority.Global).toBe(0);
-        });
-
-        test("priorities are correctly ordered", () => {
-            expect(KeyboardPriority.Modal).toBeGreaterThan(KeyboardPriority.Focused);
-            expect(KeyboardPriority.Focused).toBeGreaterThan(KeyboardPriority.Global);
-        });
-    });
-});
-

package/src/builtins/index.ts

@@ -1,4 +0,0 @@
-export { HelpCommand, createHelpCommandForParent, createRootHelpCommand } from "./help.ts";
-export { VersionCommand, createVersionCommand, formatVersion } from "./version.ts";
-export { SettingsCommand, createSettingsCommand } from "./settings.ts";
-export type { VersionConfig } from "./version.ts";

package/src/cli/help.ts

@@ -1,174 +0,0 @@
-import type { Command, OptionDef } from "../types/command.ts";
-import { colors } from "./output/colors.ts";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyCommand = Command<any, any>;
-
-/**
- * Format usage line for a command
- */
-export function formatUsage(
-  command: AnyCommand,
-  appName = "cli"
-): string {
-  const parts = [appName, command.name];
-
-  if (command.subcommands && Object.keys(command.subcommands).length > 0) {
-    parts.push("[command]");
-  }
-
-  if (command.options && Object.keys(command.options).length > 0) {
-    parts.push("[options]");
-  }
-
-  return parts.join(" ");
-}
-
-/**
- * Format subcommands list
- */
-export function formatCommands(command: AnyCommand): string {
-  if (!command.subcommands) return "";
-
-  const entries = Object.entries(command.subcommands)
-    .filter(([, cmd]) => !cmd.hidden)
-    .map(([name, cmd]) => {
-      const aliases = cmd.aliases?.length ? ` (${cmd.aliases.join(", ")})` : "";
-      return `  ${colors.cyan(name)}${aliases}  ${cmd.description}`;
-    });
-
-  if (entries.length === 0) return "";
-
-  return ["Commands:", ...entries].join("\n");
-}
-
-/**
- * Format options list
- */
-export function formatOptions(command: AnyCommand): string {
-  if (!command.options) return "";
-
-  const entries = Object.entries(command.options).map(([name, defUntyped]) => {
-    const def = defUntyped as OptionDef;
-    const alias = def.alias ? `-${def.alias}, ` : "    ";
-    const flag = `${alias}--${name}`;
-    const required = def.required ? colors.red("*") : "";
-    const defaultVal = def.default !== undefined ? ` (default: ${def.default})` : "";
-    const enumVals = def.enum ? ` [${def.enum.join("|")}]` : "";
-
-    return `  ${colors.yellow(flag)}${required}  ${def.description}${enumVals}${defaultVal}`;
-  });
-
-  if (entries.length === 0) return "";
-
-  return ["Options:", ...entries].join("\n");
-}
-
-/**
- * Format examples list
- */
-export function formatExamples(command: AnyCommand): string {
-  if (!command.examples?.length) return "";
-
-  const entries = command.examples.map(
-    (ex) => `  ${colors.dim("$")} ${ex.command}\n    ${colors.dim(ex.description)}`
-  );
-
-  return ["Examples:", ...entries].join("\n");
-}
-
-/**
- * Format global options (log-level, detailed-logs)
- */
-export function formatGlobalOptions(): string {
-  const entries = [
-    `  ${colors.yellow("--log-level")} <level>  Set log level [silly|trace|debug|info|warn|error|fatal]`,
-    `  ${colors.yellow("--detailed-logs")}      Enable detailed log output`,
-    `  ${colors.yellow("--no-detailed-logs")}   Disable detailed log output`,
-  ];
-
-  return ["Global Options:", ...entries].join("\n");
-}
-
-/**
- * Get command summary line
- */
-export function getCommandSummary(command: AnyCommand): string {
-  const aliases = command.aliases?.length ? ` (${command.aliases.join(", ")})` : "";
-  return `${command.name}${aliases}: ${command.description}`;
-}
-
-/**
- * Generate full help text for a command
- */
-export function generateHelp(
-  command: AnyCommand,
-  options: { appName?: string; version?: string } = {}
-): string {
-  const { appName = "cli", version } = options;
-  const sections: string[] = [];
-
-  // Header
-  if (version) {
-    sections.push(`${colors.bold(appName)} ${colors.dim(`v${version}`)}`);
-  }
-
-  // Description
-  sections.push(command.description);
-
-  // Usage
-  sections.push(`\n${colors.bold("Usage:")}\n  ${formatUsage(command, appName)}`);
-
-  // Commands
-  const commandsSection = formatCommands(command);
-  if (commandsSection) {
-    sections.push(`\n${commandsSection}`);
-  }
-
-  // Options
-  const optionsSection = formatOptions(command);
-  if (optionsSection) {
-    sections.push(`\n${optionsSection}`);
-  }
-
-  // Examples
-  const examplesSection = formatExamples(command);
-  if (examplesSection) {
-    sections.push(`\n${examplesSection}`);
-  }
-
-  return sections.join("\n");
-}
-
-/**
- * Generate help text for a specific command (includes global options)
- */
-export function generateCommandHelp(
-  command: AnyCommand,
-  appName = "cli"
-): string {
-  const sections: string[] = [];
-
-  // Description
-  sections.push(command.description);
-
-  // Usage
-  sections.push(`\n${colors.bold("Usage:")}\n  ${formatUsage(command, appName)}`);
-
-  // Options
-  const optionsSection = formatOptions(command);
-  if (optionsSection) {
-    sections.push(`\n${optionsSection}`);
-  }
-
-  // Global Options
-  sections.push(`\n${formatGlobalOptions()}`);
-
-  // Examples
-  const examplesSection = formatExamples(command);
-  if (examplesSection) {
-    sections.push(`\n${examplesSection}`);
-  }
-
-  return sections.join("\n");
-}

package/src/cli/index.ts

@@ -1,3 +0,0 @@
-export * from "./parser.ts";
-export * from "./help.ts";
-export * from "./output/index.ts";

package/src/cli/output/index.ts

@@ -1,2 +0,0 @@
-export * from "./colors.ts";
-export * from "./table.ts";

package/src/cli/output/table.ts

@@ -1,141 +0,0 @@
-/**
- * Column configuration for tables
- */
-export interface ColumnConfig {
-  key: string;
-  header?: string;
-  width?: number;
-  align?: "left" | "right" | "center";
-  formatter?: (value: unknown) => string;
-}
-
-export interface TableOptions {
-  columns?: (string | ColumnConfig)[];
-  showHeaders?: boolean;
-  border?: boolean;
-}
-
-/**
- * Create a formatted table string
- */
-export function table<T extends Record<string, unknown>>(
-  data: T[],
-  options: TableOptions = {}
-): string {
-  if (data.length === 0) return "";
-
-  const { showHeaders = true } = options;
-
-  // Determine columns
-  const columns: ColumnConfig[] = options.columns
-    ? options.columns.map((col) =>
-        typeof col === "string" ? { key: col, header: col } : col
-      )
-    : Object.keys(data[0] ?? {}).map((key) => ({ key, header: key }));
-
-  // Calculate column widths
-  const widths = columns.map((col) => {
-    const headerWidth = (col.header ?? col.key).length;
-    const maxDataWidth = Math.max(
-      ...data.map((row) => {
-        const value = row[col.key];
-        const formatted = col.formatter ? col.formatter(value) : String(value ?? "");
-        return formatted.length;
-      })
-    );
-    return col.width ?? Math.max(headerWidth, maxDataWidth);
-  });
-
-  // Format a row
-  const formatRow = (values: string[]): string => {
-    return values
-      .map((val, i) => {
-        const width = widths[i] ?? 10;
-        const col = columns[i];
-        const align = col?.align ?? "left";
-
-        if (align === "right") {
-          return val.padStart(width);
-        } else if (align === "center") {
-          const leftPad = Math.floor((width - val.length) / 2);
-          return val.padStart(leftPad + val.length).padEnd(width);
-        }
-        return val.padEnd(width);
-      })
-      .join("  ");
-  };
-
-  const rows: string[] = [];
-
-  // Add header
-  if (showHeaders) {
-    const headers = columns.map((col) => col.header ?? col.key);
-    rows.push(formatRow(headers));
-    rows.push(widths.map((w) => "-".repeat(w)).join("  "));
-  }
-
-  // Add data rows
-  for (const row of data) {
-    const values = columns.map((col) => {
-      const value = row[col.key];
-      return col.formatter ? col.formatter(value) : String(value ?? "");
-    });
-    rows.push(formatRow(values));
-  }
-
-  return rows.join("\n");
-}
-
-/**
- * Create a key-value list
- */
-export function keyValueList(
-  data: Record<string, unknown>,
-  options: { separator?: string } = {}
-): string {
-  const { separator = ":" } = options;
-
-  const entries = Object.entries(data);
-  if (entries.length === 0) return "";
-
-  const maxKeyLength = Math.max(...entries.map(([key]) => key.length));
-
-  return entries
-    .map(([key, value]) => `${key.padEnd(maxKeyLength)}${separator} ${value}`)
-    .join("\n");
-}
-
-/**
- * Create a bullet list
- */
-export function bulletList(
-  items: string[],
-  options: { bullet?: string; indent?: number } = {}
-): string {
-  const { bullet = "•", indent = 0 } = options;
-
-  if (items.length === 0) return "";
-
-  const prefix = " ".repeat(indent);
-  return items.map((item) => `${prefix}${bullet} ${item}`).join("\n");
-}
-
-/**
- * Create a numbered list
- */
-export function numberedList(
-  items: string[],
-  options: { start?: number; indent?: number } = {}
-): string {
-  const { start = 1, indent = 0 } = options;
-
-  if (items.length === 0) return "";
-
-  const prefix = " ".repeat(indent);
-  const maxNum = start + items.length - 1;
-  const numWidth = String(maxNum).length;
-
-  return items
-    .map((item, i) => `${prefix}${String(start + i).padStart(numWidth)}. ${item}`)
-    .join("\n");
-}

package/src/commands/help.ts

@@ -1,50 +0,0 @@
-import { defineCommand, type Command } from "../types/command.ts";
-import { generateHelp } from "../cli/help.ts";
-
-interface HelpCommandOptions {
-  getCommands: () => Command[];
-  appName?: string;
-  version?: string;
-}
-
-/**
- * Create a help command
- */
-export function createHelpCommand(options: HelpCommandOptions) {
-  const { getCommands, appName = "cli", version } = options;
-
-  return defineCommand({
-    name: "help",
-    description: "Show help information",
-    aliases: ["--help", "-h"],
-    hidden: true,
-    options: {
-      command: {
-        type: "string" as const,
-        description: "Command to show help for",
-      },
-    },
-    execute: (ctx) => {
-      const commands = getCommands();
-      const commandName = ctx.options["command"];
-
-      if (commandName && typeof commandName === "string") {
-        const cmd = commands.find((c) => c.name === commandName);
-        if (cmd) {
-          console.log(generateHelp(cmd, { appName, version }));
-          return;
-        }
-      }
-
-      // Show root help
-      const rootCommand = defineCommand({
-        name: appName,
-        description: `${appName} CLI`,
-        subcommands: Object.fromEntries(commands.map((c) => [c.name, c])),
-        execute: () => {},
-      });
-
-      console.log(generateHelp(rootCommand, { appName, version }));
-    },
-  });
-}

package/src/commands/index.ts

@@ -1 +0,0 @@
-export * from "./help.ts";

package/src/components/index.ts

@@ -1,147 +0,0 @@
-import React from "react";
-
-/**
- * Box component props
- */
-export interface BoxProps {
-  children?: React.ReactNode;
-  flexDirection?: "row" | "column";
-  padding?: number;
-  margin?: number;
-  borderStyle?: "single" | "double" | "round" | "none";
-}
-
-/**
- * Box component for layout
- */
-export function Box({ children }: BoxProps) {
-  return React.createElement("div", null, children);
-}
-
-/**
- * Text component props
- */
-export interface TextProps {
-  children?: React.ReactNode;
-  color?: string;
-  bold?: boolean;
-  dim?: boolean;
-}
-
-/**
- * Text component for styled text
- */
-export function Text({ children }: TextProps) {
-  return React.createElement("span", null, children);
-}
-
-/**
- * Input component props
- */
-export interface InputProps {
-  value: string;
-  onChange: (value: string) => void;
-  placeholder?: string;
-  disabled?: boolean;
-}
-
-/**
- * Input component
- */
-export function Input({ value, onChange, placeholder }: InputProps) {
-  return React.createElement("input", {
-    value,
-    onChange: (e: { target: { value: string } }) => onChange(e.target.value),
-    placeholder,
-  });
-}
-
-/**
- * Select option
- */
-export interface SelectOption {
-  label: string;
-  value: string;
-}
-
-/**
- * Select component props
- */
-export interface SelectProps {
-  options: SelectOption[];
-  value?: string;
-  onChange: (value: string) => void;
-}
-
-/**
- * Select component
- */
-export function Select({ options, value, onChange }: SelectProps) {
-  return React.createElement(
-    "select",
-    { value, onChange: (e: { target: { value: string } }) => onChange(e.target.value) },
-    options.map((opt) =>
-      React.createElement("option", { key: opt.value, value: opt.value }, opt.label)
-    )
-  );
-}
-
-/**
- * Button component props
- */
-export interface ButtonProps {
-  label: string;
-  onPress: () => void;
-  disabled?: boolean;
-  variant?: "primary" | "secondary" | "danger";
-}
-
-/**
- * Button component
- */
-export function Button({ label, onPress, disabled }: ButtonProps) {
-  return React.createElement("button", { onClick: onPress, disabled }, label);
-}
-
-/**
- * Modal component props
- */
-export interface ModalProps {
-  isOpen: boolean;
-  onClose: () => void;
-  title?: string;
-  children: React.ReactNode;
-}
-
-/**
- * Modal component
- */
-export function Modal({ isOpen, onClose, title, children }: ModalProps) {
-  if (!isOpen) return null;
-
-  return React.createElement(
-    "div",
-    { className: "modal" },
-    React.createElement(
-      "div",
-      { className: "modal-content" },
-      title && React.createElement("h2", null, title),
-      children,
-      React.createElement("button", { onClick: onClose }, "Close")
-    )
-  );
-}
-
-/**
- * Spinner component props
- */
-export interface SpinnerProps {
-  label?: string;
-}
-
-/**
- * Spinner component
- */
-export function Spinner({ label }: SpinnerProps) {
-  return React.createElement("span", null, label ?? "Loading...");
-}

package/src/core/index.ts

@@ -1,15 +0,0 @@
-// Core exports
-export { Application, type ApplicationConfig, type ApplicationHooks, type GlobalOptions } from "./application.ts";
-export { AppContext, type AppConfig } from "./context.ts";
-export { Command, ConfigValidationError, AbortError, type AnyCommand, type CommandExample, type CommandResult, type CommandExecutionContext } from "./command.ts";
-export { CommandRegistry, type ResolveResult } from "./registry.ts";
-export { Logger, createLogger, LogLevel, type LoggerConfig, type LogEvent } from "./logger.ts";
-export {
-  generateCommandHelp,
-  generateAppHelp,
-  formatUsage,
-  formatSubCommands,
-  formatOptions,
-  formatExamples,
-  type HelpOptions,
-} from "./help.ts";

package/src/hooks/index.ts

@@ -1,131 +0,0 @@
-import { useState, useCallback } from "react";
-import type { Command, OptionSchema, OptionValues } from "../types/command.ts";
-
-/**
- * Hook for command execution
- */
-export function useCommand<T extends OptionSchema>(command: Command<T>) {
-  const [isExecuting, setIsExecuting] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  const execute = useCallback(
-    async (options: OptionValues<T>) => {
-      setIsExecuting(true);
-      setError(null);
-
-      try {
-        await command.execute({
-          options,
-          args: [],
-          commandPath: [command.name],
-        });
-      } catch (err) {
-        setError(err instanceof Error ? err : new Error(String(err)));
-      } finally {
-        setIsExecuting(false);
-      }
-    },
-    [command]
-  );
-
-  return { execute, isExecuting, error };
-}
-
-/**
- * Hook for managing options state
- */
-export function useOptions<T extends OptionSchema>(
-  schema: T,
-  initialValues?: Partial<OptionValues<T>>
-) {
-  const [values, setValues] = useState<OptionValues<T>>(() => {
-    const defaults: Record<string, unknown> = {};
-    for (const [key, def] of Object.entries(schema)) {
-      defaults[key] = initialValues?.[key as keyof T] ?? def.default;
-    }
-    return defaults as OptionValues<T>;
-  });
-
-  const setValue = useCallback(
-    <K extends keyof T>(key: K, value: OptionValues<T>[K]) => {
-      setValues((prev) => ({ ...prev, [key]: value }));
-    },
-    []
-  );
-
-  const reset = useCallback(() => {
-    const defaults: Record<string, unknown> = {};
-    for (const [key, def] of Object.entries(schema)) {
-      defaults[key] = def.default;
-    }
-    setValues(defaults as OptionValues<T>);
-  }, [schema]);
-
-  return { values, setValue, setValues, reset };
-}
-
-/**
- * Hook for navigation between views
- */
-export function useNavigation(views: string[], initialView?: string) {
-  const [currentView, setCurrentView] = useState(initialView ?? views[0] ?? "");
-  const [history, setHistory] = useState<string[]>([]);
-
-  const navigate = useCallback((view: string) => {
-    setHistory((prev) => [...prev, currentView]);
-    setCurrentView(view);
-  }, [currentView]);
-
-  const goBack = useCallback(() => {
-    const prev = history[history.length - 1];
-    if (prev) {
-      setHistory((h) => h.slice(0, -1));
-      setCurrentView(prev);
-    }
-  }, [history]);
-
-  const canGoBack = history.length > 0;
-
-  return { currentView, navigate, goBack, canGoBack };
-}
-
-/**
- * Hook for modal state
- */
-export function useModal(initialOpen = false) {
-  const [isOpen, setIsOpen] = useState(initialOpen);
-
-  const open = useCallback(() => setIsOpen(true), []);
-  const close = useCallback(() => setIsOpen(false), []);
-  const toggle = useCallback(() => setIsOpen((prev) => !prev), []);
-
-  return { isOpen, open, close, toggle };
-}
-
-/**
- * Hook for async operations
- */
-export function useAsync<T>(asyncFn: () => Promise<T>) {
-  const [data, setData] = useState<T | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  const execute = useCallback(async () => {
-    setIsLoading(true);
-    setError(null);
-
-    try {
-      const result = await asyncFn();
-      setData(result);
-      return result;
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      setError(error);
-      throw error;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [asyncFn]);
-
-  return { data, isLoading, error, execute };
-}