@pablozaiden/terminatui 0.1.2 → 0.3.0-beta-1

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

package/src/__tests__/registryNew.test.ts

@@ -1,160 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { CommandRegistry } from "../core/registry.ts";
-import { Command } from "../core/command.ts";
-import type { AppContext } from "../core/context.ts";
-import type { OptionSchema } from "../types/command.ts";
-
-// Test command implementations
-class TestCommand extends Command<OptionSchema> {
-  constructor(
-    public readonly name: string,
-    public readonly description: string = "Test command"
-  ) {
-    super();
-  }
-  readonly options = {};
-
-  override async execute(_ctx: AppContext): Promise<void> {}
-}
-
-describe("CommandRegistry (new)", () => {
-  let registry: CommandRegistry;
-
-  beforeEach(() => {
-    registry = new CommandRegistry();
-  });
-
-  describe("register", () => {
-    test("registers a command", () => {
-      const cmd = new TestCommand("test");
-      registry.register(cmd);
-      expect(registry.has("test")).toBe(true);
-    });
-
-    test("throws on duplicate registration", () => {
-      const cmd = new TestCommand("test");
-      registry.register(cmd);
-      expect(() => registry.register(cmd)).toThrow(
-        "Command 'test' is already registered"
-      );
-    });
-  });
-
-  describe("registerAll", () => {
-    test("registers multiple commands", () => {
-      const cmd1 = new TestCommand("cmd1");
-      const cmd2 = new TestCommand("cmd2");
-      registry.registerAll([cmd1, cmd2]);
-      expect(registry.has("cmd1")).toBe(true);
-      expect(registry.has("cmd2")).toBe(true);
-    });
-  });
-
-  describe("get", () => {
-    test("returns command by name", () => {
-      const cmd = new TestCommand("test");
-      registry.register(cmd);
-      expect(registry.get("test")).toBe(cmd);
-    });
-
-    test("returns undefined for unknown command", () => {
-      expect(registry.get("unknown")).toBeUndefined();
-    });
-  });
-
-  describe("has", () => {
-    test("returns true for registered command", () => {
-      registry.register(new TestCommand("test"));
-      expect(registry.has("test")).toBe(true);
-    });
-
-    test("returns false for unknown command", () => {
-      expect(registry.has("unknown")).toBe(false);
-    });
-  });
-
-  describe("list", () => {
-    test("returns empty array for empty registry", () => {
-      expect(registry.list()).toEqual([]);
-    });
-
-    test("returns all registered commands", () => {
-      const cmd1 = new TestCommand("cmd1");
-      const cmd2 = new TestCommand("cmd2");
-      registry.registerAll([cmd1, cmd2]);
-      expect(registry.list()).toContain(cmd1);
-      expect(registry.list()).toContain(cmd2);
-    });
-  });
-
-  describe("names", () => {
-    test("returns command names", () => {
-      registry.register(new TestCommand("cmd1"));
-      registry.register(new TestCommand("cmd2"));
-      expect(registry.names()).toContain("cmd1");
-      expect(registry.names()).toContain("cmd2");
-    });
-  });
-
-  describe("resolve", () => {
-    test("returns undefined for empty path", () => {
-      const result = registry.resolve([]);
-      expect(result.command).toBeUndefined();
-    });
-
-    test("resolves single command", () => {
-      const cmd = new TestCommand("test");
-      registry.register(cmd);
-      const result = registry.resolve(["test"]);
-      expect(result.command).toBe(cmd);
-      expect(result.resolvedPath).toEqual(["test"]);
-      expect(result.remainingPath).toEqual([]);
-    });
-
-    test("returns undefined for unknown command", () => {
-      const result = registry.resolve(["unknown"]);
-      expect(result.command).toBeUndefined();
-      expect(result.remainingPath).toEqual(["unknown"]);
-    });
-
-    test("resolves nested subcommands", () => {
-      const subCmd = new TestCommand("sub");
-      const cmd = new TestCommand("parent");
-      cmd.subCommands = [subCmd];
-      registry.register(cmd);
-
-      const result = registry.resolve(["parent", "sub"]);
-      expect(result.command).toBe(subCmd);
-      expect(result.resolvedPath).toEqual(["parent", "sub"]);
-      expect(result.remainingPath).toEqual([]);
-    });
-
-    test("returns remaining path for unresolved parts", () => {
-      const cmd = new TestCommand("parent");
-      registry.register(cmd);
-
-      const result = registry.resolve(["parent", "unknown"]);
-      expect(result.command).toBe(cmd);
-      expect(result.resolvedPath).toEqual(["parent"]);
-      expect(result.remainingPath).toEqual(["unknown"]);
-    });
-  });
-
-  describe("clear", () => {
-    test("clears all commands", () => {
-      registry.register(new TestCommand("test"));
-      registry.clear();
-      expect(registry.size).toBe(0);
-    });
-  });
-
-  describe("size", () => {
-    test("returns number of registered commands", () => {
-      expect(registry.size).toBe(0);
-      registry.register(new TestCommand("cmd1"));
-      expect(registry.size).toBe(1);
-      registry.register(new TestCommand("cmd2"));
-      expect(registry.size).toBe(2);
-    });
-  });
-});

package/src/__tests__/table.test.ts

@@ -1,146 +0,0 @@
-import { test, expect, describe } from "bun:test";
-import { table, keyValueList, bulletList, numberedList } from "../cli/output/table.ts";
-
-describe("table", () => {
-  test("creates table with data and columns", () => {
-    const data = [
-      { name: "Alice", age: 30 },
-      { name: "Bob", age: 25 },
-    ];
-    const result = table(data, { columns: ["name", "age"] });
-
-    expect(result).toContain("name");
-    expect(result).toContain("Alice");
-    expect(result).toContain("Bob");
-  });
-
-  test("handles empty data", () => {
-    const result = table([]);
-    expect(result).toBe("");
-  });
-
-  test("handles single row", () => {
-    const data = [{ col: "value" }];
-    const result = table(data);
-    expect(result).toContain("value");
-  });
-
-  test("handles multiple columns", () => {
-    const data = [{ a: "1", b: "2", c: "3" }];
-    const result = table(data);
-    expect(result).toContain("1");
-    expect(result).toContain("2");
-    expect(result).toContain("3");
-  });
-
-  test("handles custom column config", () => {
-    const data = [{ value: 123 }];
-    const result = table(data, {
-      columns: [{ key: "value", header: "Amount" }],
-    });
-    expect(result).toContain("Amount");
-  });
-
-  test("handles custom formatter", () => {
-    const data = [{ price: 100 }];
-    const result = table(data, {
-      columns: [
-        {
-          key: "price",
-          formatter: (v) => `$${v}`,
-        },
-      ],
-    });
-    expect(result).toContain("$100");
-  });
-
-  test("hides headers when showHeaders is false", () => {
-    const data = [{ name: "Test" }];
-    const result = table(data, { showHeaders: false });
-    expect(result).not.toContain("---");
-  });
-
-  test("handles undefined values", () => {
-    const data = [{ a: undefined }];
-    const result = table(data);
-    expect(typeof result).toBe("string");
-  });
-});
-
-describe("keyValueList", () => {
-  test("formats key-value pairs", () => {
-    const data = { name: "Test", version: "1.0" };
-    const result = keyValueList(data);
-    expect(result).toContain("name");
-    expect(result).toContain("Test");
-    expect(result).toContain("version");
-    expect(result).toContain("1.0");
-  });
-
-  test("handles empty object", () => {
-    const result = keyValueList({});
-    expect(result).toBe("");
-  });
-
-  test("handles custom separator", () => {
-    const data = { key: "value" };
-    const result = keyValueList(data, { separator: " =" });
-    expect(result).toContain("=");
-  });
-});
-
-describe("bulletList", () => {
-  test("formats bullet list", () => {
-    const items = ["one", "two", "three"];
-    const result = bulletList(items);
-    expect(result).toContain("•");
-    expect(result).toContain("one");
-    expect(result).toContain("two");
-    expect(result).toContain("three");
-  });
-
-  test("handles empty array", () => {
-    const result = bulletList([]);
-    expect(result).toBe("");
-  });
-
-  test("handles custom bullet", () => {
-    const items = ["item"];
-    const result = bulletList(items, { bullet: "-" });
-    expect(result).toContain("-");
-  });
-
-  test("handles indent", () => {
-    const items = ["item"];
-    const result = bulletList(items, { indent: 2 });
-    expect(result.startsWith("  ")).toBe(true);
-  });
-});
-
-describe("numberedList", () => {
-  test("formats numbered list", () => {
-    const items = ["first", "second"];
-    const result = numberedList(items);
-    expect(result).toContain("1.");
-    expect(result).toContain("2.");
-    expect(result).toContain("first");
-    expect(result).toContain("second");
-  });
-
-  test("handles empty array", () => {
-    const result = numberedList([]);
-    expect(result).toBe("");
-  });
-
-  test("handles custom start number", () => {
-    const items = ["item"];
-    const result = numberedList(items, { start: 5 });
-    expect(result).toContain("5.");
-  });
-
-  test("handles indent", () => {
-    const items = ["item"];
-    const result = numberedList(items, { indent: 2 });
-    expect(result.startsWith("  ")).toBe(true);
-  });
-});