@pablozaiden/terminatui 0.2.0 → 0.3.0

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 };
-}

package/src/registry/commandRegistry.ts

@@ -1,77 +0,0 @@
-import type { Command, OptionSchema } from "../types/command.ts";
-
-/**
- * Command registry for managing commands
- */
-export interface CommandRegistry<T extends OptionSchema = OptionSchema> {
-  register(command: Command<T>): void;
-  get(name: string): Command<T> | undefined;
-  resolve(nameOrAlias: string): Command<T> | undefined;
-  has(nameOrAlias: string): boolean;
-  list(): Command<T>[];
-  getNames(): string[];
-  getCommandMap(): Record<string, Command<T>>;
-}
-
-/**
- * Create a command registry
- */
-export function createCommandRegistry<
-  T extends OptionSchema = OptionSchema,
->(): CommandRegistry<T> {
-  const commands = new Map<string, Command<T>>();
-  const aliases = new Map<string, string>();
-
-  return {
-    register(command: Command<T>): void {
-      if (commands.has(command.name)) {
-        throw new Error(`Command "${command.name}" is already registered`);
-      }
-
-      commands.set(command.name, command);
-
-      if (command.aliases) {
-        for (const alias of command.aliases) {
-          if (aliases.has(alias) || commands.has(alias)) {
-            throw new Error(`Alias "${alias}" conflicts with existing command or alias`);
-          }
-          aliases.set(alias, command.name);
-        }
-      }
-    },
-
-    get(name: string): Command<T> | undefined {
-      return commands.get(name);
-    },
-
-    resolve(nameOrAlias: string): Command<T> | undefined {
-      // Try direct name first
-      const cmd = commands.get(nameOrAlias);
-      if (cmd) return cmd;
-
-      // Try alias
-      const resolvedName = aliases.get(nameOrAlias);
-      if (resolvedName) {
-        return commands.get(resolvedName);
-      }
-
-      return undefined;
-    },
-
-    has(nameOrAlias: string): boolean {
-      return commands.has(nameOrAlias) || aliases.has(nameOrAlias);
-    },
-
-    list(): Command<T>[] {
-      return Array.from(commands.values());
-    },
-
-    getNames(): string[] {
-      return Array.from(commands.keys());
-    },
-
-    getCommandMap(): Record<string, Command<T>> {
-      return Object.fromEntries(commands);
-    },
-  };
-}

package/src/registry/index.ts

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