@pablozaiden/terminatui 0.2.0 → 0.3.0

package/src/__tests__/colors.test.ts

@@ -1,127 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import { colors, supportsColors } from "../cli/output/colors.ts";
-
-describe("colors", () => {
-  describe("basic colors", () => {
-    test("red wraps text", () => {
-      const result = colors.red("test");
-      expect(result).toContain("test");
-    });
-
-    test("green wraps text", () => {
-      const result = colors.green("test");
-      expect(result).toContain("test");
-    });
-
-    test("blue wraps text", () => {
-      const result = colors.blue("test");
-      expect(result).toContain("test");
-    });
-
-    test("yellow wraps text", () => {
-      const result = colors.yellow("test");
-      expect(result).toContain("test");
-    });
-
-    test("cyan wraps text", () => {
-      const result = colors.cyan("test");
-      expect(result).toContain("test");
-    });
-
-    test("gray wraps text", () => {
-      const result = colors.gray("test");
-      expect(result).toContain("test");
-    });
-  });
-
-  describe("styles", () => {
-    test("bold wraps text", () => {
-      const result = colors.bold("test");
-      expect(result).toContain("test");
-    });
-
-    test("dim wraps text", () => {
-      const result = colors.dim("test");
-      expect(result).toContain("test");
-    });
-
-    test("italic wraps text", () => {
-      const result = colors.italic("test");
-      expect(result).toContain("test");
-    });
-
-    test("underline wraps text", () => {
-      const result = colors.underline("test");
-      expect(result).toContain("test");
-    });
-
-    test("strikethrough wraps text", () => {
-      const result = colors.strikethrough("test");
-      expect(result).toContain("test");
-    });
-  });
-
-  describe("semantic colors", () => {
-    test("success includes checkmark and message", () => {
-      const result = colors.success("done");
-      expect(result).toContain("done");
-      expect(result).toContain("✓");
-    });
-
-    test("error includes message", () => {
-      const result = colors.error("failed");
-      expect(result).toContain("failed");
-    });
-
-    test("warning includes message", () => {
-      const result = colors.warning("caution");
-      expect(result).toContain("caution");
-    });
-
-    test("info includes message", () => {
-      const result = colors.info("note");
-      expect(result).toContain("note");
-    });
-  });
-
-  describe("chaining", () => {
-    test("can combine bold and red", () => {
-      const result = colors.bold(colors.red("test"));
-      expect(result).toContain("test");
-    });
-
-    test("can combine dim and italic", () => {
-      const result = colors.dim(colors.italic("test"));
-      expect(result).toContain("test");
-    });
-  });
-
-  describe("edge cases", () => {
-    test("handles empty string", () => {
-      const result = colors.red("");
-      expect(typeof result).toBe("string");
-    });
-
-    test("handles string with newlines", () => {
-      const result = colors.blue("line1\nline2");
-      expect(result).toContain("line1");
-      expect(result).toContain("line2");
-    });
-
-    test("handles string with special characters", () => {
-      const result = colors.green("test © ® ™");
-      expect(result).toContain("©");
-    });
-  });
-});
-
-describe("supportsColors", () => {
-  test("is a function", () => {
-    expect(typeof supportsColors).toBe("function");
-  });
-
-  test("returns a boolean", () => {
-    const result = supportsColors();
-    expect(typeof result).toBe("boolean");
-  });
-});

package/src/__tests__/commandClass.test.ts

@@ -1,130 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { Command, type CommandResult } from "../core/command.ts";
-import type { AppContext } from "../core/context.ts";
-import type { OptionSchema, OptionValues } from "../types/command.ts";
-
-// Test command with options
-class TestCommand extends Command<{ name: { type: "string"; description: string } }> {
-  readonly name = "test";
-  readonly description = "A test command";
-  readonly options = {
-    name: { type: "string" as const, description: "Name option" },
-  };
-
-  executedWith: OptionValues<typeof this.options> | null = null;
-
-  override async execute(
-    _ctx: AppContext,
-    opts: OptionValues<typeof this.options>
-  ): Promise<CommandResult> {
-    this.executedWith = opts;
-    return { success: true, message: "Executed" };
-  }
-}
-
-// Simple command without options
-class SimpleCommand extends Command<OptionSchema> {
-  readonly name = "simple";
-  readonly description = "A simple command";
-  readonly options = {};
-
-  executed = false;
-
-  override async execute(_ctx: AppContext): Promise<CommandResult> {
-    this.executed = true;
-    return { success: true, message: "Done" };
-  }
-}
-
-describe("Command", () => {
-  describe("core properties", () => {
-    test("has name", () => {
-      const cmd = new TestCommand();
-      expect(cmd.name).toBe("test");
-    });
-
-    test("has description", () => {
-      const cmd = new TestCommand();
-      expect(cmd.description).toBe("A test command");
-    });
-
-    test("has options", () => {
-      const cmd = new TestCommand();
-      expect(cmd.options).toEqual({
-        name: { type: "string", description: "Name option" },
-      });
-    });
-  });
-
-  describe("optional metadata", () => {
-    test("subCommands defaults to undefined", () => {
-      const cmd = new TestCommand();
-      expect(cmd.subCommands).toBeUndefined();
-    });
-
-    test("examples defaults to undefined", () => {
-      const cmd = new TestCommand();
-      expect(cmd.examples).toBeUndefined();
-    });
-
-    test("longDescription defaults to undefined", () => {
-      const cmd = new TestCommand();
-      expect(cmd.longDescription).toBeUndefined();
-    });
-  });
-
-  describe("supportsCli", () => {
-    test("returns true for command with execute", () => {
-      const cmd = new TestCommand();
-      expect(cmd.supportsCli()).toBe(true);
-    });
-  });
-
-  describe("supportsTui", () => {
-    test("returns true for command with execute", () => {
-      const cmd = new TestCommand();
-      expect(cmd.supportsTui()).toBe(true);
-    });
-  });
-
-  describe("both modes", () => {
-    test("command supports both CLI and TUI", () => {
-      const cmd = new TestCommand();
-      expect(cmd.supportsCli()).toBe(true);
-      expect(cmd.supportsTui()).toBe(true);
-    });
-  });
-
-  describe("validate", () => {
-    test("passes for command with execute", () => {
-      const cmd = new TestCommand();
-      expect(() => cmd.validate()).not.toThrow();
-    });
-  });
-
-  describe("subcommands", () => {
-    test("hasSubCommands returns false when no subcommands", () => {
-      const cmd = new TestCommand();
-      expect(cmd.hasSubCommands()).toBe(false);
-    });
-
-    test("hasSubCommands returns true when subcommands exist", () => {
-      const cmd = new TestCommand();
-      cmd.subCommands = [new SimpleCommand()];
-      expect(cmd.hasSubCommands()).toBe(true);
-    });
-
-    test("getSubCommand finds subcommand by name", () => {
-      const cmd = new TestCommand();
-      const subCmd = new SimpleCommand();
-      cmd.subCommands = [subCmd];
-      expect(cmd.getSubCommand("simple")).toBe(subCmd);
-    });
-
-    test("getSubCommand returns undefined for unknown name", () => {
-      const cmd = new TestCommand();
-      cmd.subCommands = [new SimpleCommand()];
-      expect(cmd.getSubCommand("unknown")).toBeUndefined();
-    });
-  });
-});

package/src/__tests__/help.test.ts

@@ -1,412 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import {
-  generateHelp,
-  formatUsage,
-  formatCommands,
-  formatOptions,
-  formatExamples,
-  getCommandSummary,
-  formatGlobalOptions,
-  generateCommandHelp,
-} from "../cli/help.ts";
-import { defineCommand } from "../types/command.ts";
-
-describe("Help Generation", () => {
-  describe("formatUsage", () => {
-    test("formats basic usage", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test command",
-        execute: () => {},
-      });
-
-      const usage = formatUsage(cmd, "myapp");
-      expect(usage).toContain("myapp");
-      expect(usage).toContain("test");
-    });
-
-    test("includes [command] for commands with subcommands", () => {
-      const cmd = defineCommand({
-        name: "parent",
-        description: "Parent command",
-        subcommands: {
-          child: defineCommand({
-            name: "child",
-            description: "Child",
-            execute: () => {},
-          }),
-        },
-        execute: () => {},
-      });
-
-      const usage = formatUsage(cmd);
-      expect(usage).toContain("[command]");
-    });
-
-    test("includes [options] for commands with options", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test command",
-        options: {
-          verbose: { type: "boolean", description: "Verbose" },
-        },
-        execute: () => {},
-      });
-
-      const usage = formatUsage(cmd);
-      expect(usage).toContain("[options]");
-    });
-  });
-
-  describe("formatCommands", () => {
-    test("formats subcommands list", () => {
-      const cmd = defineCommand({
-        name: "parent",
-        description: "Parent",
-        subcommands: {
-          child: defineCommand({
-            name: "child",
-            description: "Child command",
-            execute: () => {},
-          }),
-        },
-        execute: () => {},
-      });
-
-      const commands = formatCommands(cmd);
-      expect(commands).toContain("child");
-      expect(commands).toContain("Child command");
-    });
-
-    test("excludes hidden commands", () => {
-      const cmd = defineCommand({
-        name: "parent",
-        description: "Parent",
-        subcommands: {
-          visible: defineCommand({
-            name: "visible",
-            description: "Visible",
-            execute: () => {},
-          }),
-          hidden: defineCommand({
-            name: "hidden",
-            description: "Hidden",
-            hidden: true,
-            execute: () => {},
-          }),
-        },
-        execute: () => {},
-      });
-
-      const commands = formatCommands(cmd);
-      expect(commands).toContain("visible");
-      expect(commands).not.toMatch(/\bhidden\b/);
-    });
-
-    test("shows command aliases", () => {
-      const cmd = defineCommand({
-        name: "parent",
-        description: "Parent",
-        subcommands: {
-          list: defineCommand({
-            name: "list",
-            description: "List items",
-            aliases: ["ls", "l"],
-            execute: () => {},
-          }),
-        },
-        execute: () => {},
-      });
-
-      const commands = formatCommands(cmd);
-      expect(commands).toContain("ls");
-      expect(commands).toContain("l");
-    });
-
-    test("returns empty for no subcommands", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        execute: () => {},
-      });
-
-      const commands = formatCommands(cmd);
-      expect(commands).toBe("");
-    });
-  });
-
-  describe("formatOptions", () => {
-    test("formats options with descriptions", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        options: {
-          verbose: { type: "boolean", description: "Enable verbose" },
-        },
-        execute: () => {},
-      });
-
-      const options = formatOptions(cmd);
-      expect(options).toContain("--verbose");
-      expect(options).toContain("Enable verbose");
-    });
-
-    test("shows option aliases", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        options: {
-          verbose: { type: "boolean", alias: "v", description: "Verbose" },
-        },
-        execute: () => {},
-      });
-
-      const options = formatOptions(cmd);
-      expect(options).toContain("-v");
-    });
-
-    test("shows default values", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        options: {
-          count: { type: "number", default: 10, description: "Count" },
-        },
-        execute: () => {},
-      });
-
-      const options = formatOptions(cmd);
-      expect(options).toContain("10");
-    });
-
-    test("shows required marker", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        options: {
-          name: { type: "string", required: true, description: "Name" },
-        },
-        execute: () => {},
-      });
-
-      const options = formatOptions(cmd);
-      expect(options).toContain("*");
-    });
-
-    test("shows enum values", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        options: {
-          level: {
-            type: "string",
-            enum: ["low", "high"],
-            description: "Level",
-          },
-        },
-        execute: () => {},
-      });
-
-      const options = formatOptions(cmd);
-      expect(options).toContain("low");
-      expect(options).toContain("high");
-    });
-
-    test("returns empty for no options", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        execute: () => {},
-      });
-
-      const options = formatOptions(cmd);
-      expect(options).toBe("");
-    });
-  });
-
-  describe("formatExamples", () => {
-    test("formats examples list", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        examples: [
-          { command: "test --verbose", description: "Run with verbose" },
-        ],
-        execute: () => {},
-      });
-
-      const examples = formatExamples(cmd);
-      expect(examples).toContain("test --verbose");
-      expect(examples).toContain("Run with verbose");
-    });
-
-    test("returns empty for no examples", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        execute: () => {},
-      });
-
-      const examples = formatExamples(cmd);
-      expect(examples).toBe("");
-    });
-  });
-
-  describe("generateHelp", () => {
-    test("generates help with app name and version", () => {
-      const cmd = defineCommand({
-        name: "root",
-        description: "Root command",
-        execute: () => {},
-      });
-
-      const help = generateHelp(cmd, { appName: "myapp", version: "1.0.0" });
-      expect(help).toContain("myapp");
-      expect(help).toContain("1.0.0");
-    });
-
-    test("includes usage section", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        execute: () => {},
-      });
-
-      const help = generateHelp(cmd);
-      expect(help).toContain("Usage:");
-    });
-
-    test("includes command description", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "A test command for testing",
-        execute: () => {},
-      });
-
-      const help = generateHelp(cmd);
-      expect(help).toContain("A test command for testing");
-    });
-
-    test("includes options section", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test",
-        options: {
-          verbose: { type: "boolean", description: "Verbose mode" },
-        },
-        execute: () => {},
-      });
-
-      const help = generateHelp(cmd);
-      expect(help).toContain("Options:");
-      expect(help).toContain("--verbose");
-    });
-
-    test("generates root help with commands", () => {
-      const cmd = defineCommand({
-        name: "root",
-        description: "Root",
-        subcommands: {
-          run: defineCommand({
-            name: "run",
-            description: "Run something",
-            execute: () => {},
-          }),
-        },
-        execute: () => {},
-      });
-
-      const help = generateHelp(cmd);
-      expect(help).toContain("Commands:");
-      expect(help).toContain("run");
-    });
-  });
-
-  describe("getCommandSummary", () => {
-    test("returns command summary", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "A test command",
-        execute: () => {},
-      });
-
-      const summary = getCommandSummary(cmd);
-      expect(summary).toContain("test");
-      expect(summary).toContain("A test command");
-    });
-
-    test("includes aliases in summary", () => {
-      const cmd = defineCommand({
-        name: "list",
-        description: "List items",
-        aliases: ["ls"],
-        execute: () => {},
-      });
-
-      const summary = getCommandSummary(cmd);
-      expect(summary).toContain("ls");
-    });
-  });
-
-  describe("formatGlobalOptions", () => {
-    test("includes --log-level option", () => {
-      const result = formatGlobalOptions();
-      expect(result).toContain("--log-level");
-      expect(result).toContain("Set log level");
-    });
-
-    test("includes log level choices", () => {
-      const result = formatGlobalOptions();
-      expect(result).toContain("silly");
-      expect(result).toContain("trace");
-      expect(result).toContain("debug");
-      expect(result).toContain("info");
-      expect(result).toContain("warn");
-      expect(result).toContain("error");
-      expect(result).toContain("fatal");
-    });
-
-    test("includes --detailed-logs option", () => {
-      const result = formatGlobalOptions();
-      expect(result).toContain("--detailed-logs");
-    });
-
-    test("includes --no-detailed-logs option", () => {
-      const result = formatGlobalOptions();
-      expect(result).toContain("--no-detailed-logs");
-    });
-  });
-
-  describe("generateCommandHelp with global options", () => {
-    test("includes Global Options section", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test command",
-        execute: () => {},
-      });
-
-      const help = generateCommandHelp(cmd, "myapp");
-      expect(help).toContain("Global Options:");
-      expect(help).toContain("--log-level");
-      expect(help).toContain("--detailed-logs");
-    });
-
-    test("global options appear after command options", () => {
-      const cmd = defineCommand({
-        name: "test",
-        description: "Test command",
-        options: {
-          verbose: { type: "boolean", description: "Verbose output" },
-        },
-        execute: () => {},
-      });
-
-      const help = generateCommandHelp(cmd, "myapp");
-      const optionsIndex = help.indexOf("Options:");
-      const globalOptionsIndex = help.indexOf("Global Options:");
-      
-      expect(optionsIndex).toBeGreaterThan(-1);
-      expect(globalOptionsIndex).toBeGreaterThan(optionsIndex);
-    });
-  });
-});