@tkeron/commands 0.3.0 → 0.4.0

package/tests/textFuncs.test.ts

@@ -0,0 +1,179 @@
+import {
+  command,
+  commands,
+  commandsCollection,
+} from "./helpers/testConstants.js";
+import {
+  buildDescriptionsText,
+  buildHelpText,
+  getCommandText,
+} from "../src/textFuncs.js";
+import { describe, expect, it } from "bun:test";
+
+describe("text Functions", () => {
+  describe("getCommandText", () => {
+    it("should return command text", () => {
+      const result = getCommandText(command);
+
+      expect(result).toBe(
+        "command_1|al1|al2   [pos1] [pos2]   [op1=opEx1] [op2=VALUE]  ",
+      );
+    });
+
+    it("should return command text without aliases", () => {
+      const result = getCommandText({ ...command, aliases: [] });
+
+      expect(result).toBe(
+        "command_1   [pos1] [pos2]   [op1=opEx1] [op2=VALUE]  ",
+      );
+    });
+  });
+  describe("buildHelpText", () => {
+    it("should return help text", () => {
+      const result = buildHelpText(commands, commandsCollection);
+      expect(result).toBe(
+        "\nheader text...\nhelp line...\nhelp line...\nhelp line...\nfooter text...\n",
+      );
+    });
+    it("should return help text without headerText", () => {
+      const result = buildHelpText(
+        { ...commands, headerText: "" },
+        commandsCollection,
+      );
+      expect(result).toBe(
+        "\n\nhelp line...\nhelp line...\nhelp line...\nfooter text...\n",
+      );
+    });
+    it("should return help text without footerText", () => {
+      const result = buildHelpText(
+        { ...commands, footerText: "" },
+        commandsCollection,
+      );
+      expect(result).toBe(
+        "\nheader text...\nhelp line...\nhelp line...\nhelp line...\n\n",
+      );
+    });
+  });
+  describe("buildDescriptionsText", () => {
+    it("should return description text", () => {
+      const result = buildDescriptionsText(commandsCollection);
+      expect(result).toBe("help line...\n".repeat(3));
+    });
+
+    it("should return empty string for empty collection", () => {
+      const result = buildDescriptionsText({});
+      expect(result).toBe("");
+    });
+  });
+
+  describe("getCommandText edge cases", () => {
+    it("should handle command with no options and no positioned args", () => {
+      const result = getCommandText({
+        ...command,
+        options: [],
+        optionsExamples: [],
+        positionedArguments: [],
+        aliases: [],
+      });
+      expect(result).toBe("command_1  ");
+    });
+
+    it("should handle command with only aliases", () => {
+      const result = getCommandText({
+        ...command,
+        options: [],
+        optionsExamples: [],
+        positionedArguments: [],
+      });
+      expect(result).toBe("command_1|al1|al2  ");
+    });
+
+    it("should use VALUE as default example when not provided", () => {
+      const result = getCommandText({
+        ...command,
+        options: ["opt1"],
+        optionsExamples: [],
+        positionedArguments: [],
+        aliases: [],
+      });
+      expect(result).toBe("command_1      [opt1=VALUE]  ");
+    });
+  });
+});
+
+describe("getCommandText with optionDefinitions", () => {
+  it("should format boolean flag with short flag", () => {
+    const command = {
+      ...commandsCollection.command_1,
+      optionDefinitions: [
+        {
+          name: "verbose",
+          shortFlag: "v",
+          type: "boolean" as const,
+          description: "Verbose output",
+        },
+      ],
+    };
+    const result = getCommandText(command);
+    expect(result).toContain("--verbose");
+    expect(result).toContain("-v");
+  });
+
+  it("should format string option with short flag", () => {
+    const command = {
+      ...commandsCollection.command_1,
+      optionDefinitions: [
+        {
+          name: "output",
+          shortFlag: "o",
+          type: "string" as const,
+          description: "Output directory",
+        },
+      ],
+    };
+    const result = getCommandText(command);
+    expect(result).toContain("--output");
+    expect(result).toContain("-o");
+  });
+
+  it("should show required marker for required options", () => {
+    const command = {
+      ...commandsCollection.command_1,
+      optionDefinitions: [
+        {
+          name: "config",
+          type: "string" as const,
+          description: "Config file",
+          required: true,
+        },
+      ],
+    };
+    const result = getCommandText(command);
+    expect(result).toContain("<config>");
+  });
+
+  it("should show optional marker for optional options", () => {
+    const command = {
+      ...commandsCollection.command_1,
+      optionDefinitions: [
+        {
+          name: "format",
+          type: "string" as const,
+          description: "Output format",
+          required: false,
+        },
+      ],
+    };
+    const result = getCommandText(command);
+    expect(result).toContain("[--format");
+  });
+
+  it("should fall back to legacy format when no optionDefinitions", () => {
+    const command = {
+      ...commandsCollection.command_1,
+      optionDefinitions: [],
+    };
+    const result = getCommandText(command);
+    expect(result).toContain("[op1=opEx1]");
+  });
+});

package/tests/validateOptions.test.ts

@@ -0,0 +1,157 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import type { Command, ParsedOptions } from "../src/types.js";
+import { validateOptions } from "../src/validateOptions.js";
+
+describe("validateOptions", () => {
+  let command: Command;
+
+  beforeEach(() => {
+    command = {
+      name: "test",
+      description: "test",
+      aliases: [],
+      options: [],
+      optionsExamples: [],
+      positionedArguments: [],
+      optionDefinitions: [],
+      getHelpLine: () => "",
+      callback: () => {},
+    };
+  });
+
+  it("should validate required option is present", () => {
+    command.optionDefinitions = [
+      {
+        name: "output",
+        type: "string",
+        description: "Output",
+        required: true,
+      },
+    ];
+    const parsed: ParsedOptions = { output: "dist" };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+
+  it("should fail when required option is missing", () => {
+    command.optionDefinitions = [
+      {
+        name: "output",
+        type: "string",
+        description: "Output",
+        required: true,
+      },
+    ];
+    const parsed: ParsedOptions = {};
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("Required option 'output' is missing");
+  });
+
+  it("should validate multiple required options", () => {
+    command.optionDefinitions = [
+      {
+        name: "output",
+        type: "string",
+        description: "Output",
+        required: true,
+      },
+      {
+        name: "input",
+        type: "string",
+        description: "Input",
+        required: true,
+      },
+    ];
+    const parsed: ParsedOptions = { output: "dist" };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("Required option 'input' is missing");
+  });
+
+  it("should validate number type is valid", () => {
+    command.optionDefinitions = [
+      {
+        name: "port",
+        type: "number",
+        description: "Port",
+      },
+    ];
+    const parsed: ParsedOptions = { port: 3000 };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(true);
+  });
+
+  it("should fail when number type is NaN", () => {
+    command.optionDefinitions = [
+      {
+        name: "port",
+        type: "number",
+        description: "Port",
+      },
+    ];
+    const parsed: ParsedOptions = { port: NaN };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("Option 'port' must be a valid number");
+  });
+
+  it("should validate allowed values", () => {
+    command.optionDefinitions = [
+      {
+        name: "format",
+        type: "string",
+        description: "Format",
+        allowedValues: ["json", "xml", "yaml"],
+      },
+    ];
+    const parsed: ParsedOptions = { format: "json" };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(true);
+  });
+
+  it("should fail when value not in allowed values", () => {
+    command.optionDefinitions = [
+      {
+        name: "format",
+        type: "string",
+        description: "Format",
+        allowedValues: ["json", "xml", "yaml"],
+      },
+    ];
+    const parsed: ParsedOptions = { format: "invalid" };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain(
+      "Option 'format' must be one of: json, xml, yaml",
+    );
+  });
+
+  it("should pass validation when no optionDefinitions", () => {
+    const parsed: ParsedOptions = { anything: "value" };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(true);
+  });
+
+  it("should validate multiple errors at once", () => {
+    command.optionDefinitions = [
+      {
+        name: "port",
+        type: "number",
+        description: "Port",
+        required: true,
+      },
+      {
+        name: "format",
+        type: "string",
+        description: "Format",
+        allowedValues: ["json", "xml"],
+      },
+    ];
+    const parsed: ParsedOptions = { format: "invalid" };
+    const result = validateOptions(parsed, command);
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(1);
+  });
+});

package/tsconfig.json

@@ -5,7 +5,6 @@
     "target": "ESNext",
     "module": "ESNext",
     "moduleDetection": "force",
-    "jsx": "react-jsx",
     "allowJs": true,
 
     // Bundler mode
@@ -20,8 +19,8 @@
     "noFallthroughCasesInSwitch": true,
 
     // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
     "noPropertyAccessFromIndexSignature": false
   }
 }

package/src/example.e2e.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it, spyOn } from "bun:test";
-
-describe("example e2e", () => {
-  const { log } = globalThis.console;
-  let logs: any[] = [];
-  spyOn(globalThis.console, "log").mockImplementation((...args: any) => {
-    logs.push(args);
-  });
-
-  it("should runs ok", (done) => {
-    expect(logs).toHaveLength(0);
-    //@ts-ignore
-    import("./example");
-    const check = () => {
-      // @ts-ignore
-      const { commands } = globalThis;
-      if (!commands) return;
-      expect(logs).toHaveLength(3);
-      expect(logs).toStrictEqual([
-        ["argument 'asdasd' not defined"],
-        ["arguments 'pos0value, pos1value, asdasd' not defined"],
-        [
-          {
-            opt1: "qw111erty",
-            opt2: "as222d",
-            pos0: "pos0value",
-            pos1: "pos1value",
-            pos3: "asdasd",
-          },
-        ],
-      ]);
-      clearInterval(handler);
-      done();
-    };
-    const handler = setInterval(check, 10);
-  });
-});

package/src/example.ts

@@ -1,69 +0,0 @@
-import { getCommands } from ".";
-import type { Commands } from "./types";
-
-const commands = getCommands("test program", "0.0.14")
-  .addCommand("com1")
-  .addAlias("c1")
-  .addOption("opt1")
-  .addOption("opt2")
-  .addDescription("command 001 test...")
-  .addPositionedArgument("pos0")
-  .addPositionedArgument("pos1")
-  .setCallback(console.log)
-
-  .commands()
-
-  .addCommand("com2")
-  .addAlias("c2")
-  .addAlias("a2")
-  .addOption("opt1")
-  .addDescription("command 002 test...")
-  .setCallback(console.log)
-
-  .commands()
-
-  .addCommand("com3")
-  .addAlias("c3")
-  .addOption("opt1")
-  .addOption("opt2", "exOpt2...")
-  .addOption("opt3")
-  .addDescription("command 003 test...")
-  .addPositionedArgument("pos0")
-  .addPositionedArgument("pos1")
-  .addPositionedArgument("pos3")
-  .setCallback(console.log)
-
-  .commands()
-
-  .addHeaderText("header...\n\n")
-  .addFooterText("\n\nFooter...");
-
-commands.start([
-  "",
-  "",
-  ..."com1 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
-    .replace(/\s+/g, " ")
-    .split(" "),
-]);
-
-commands.start([
-  "",
-  "",
-  ..."a2 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
-    .replace(/\s+/g, " ")
-    .split(" "),
-]);
-
-commands.start([
-  "",
-  "",
-  ..."c3 pos0value  opt1=qw111erty pos1value opt2=as222d  asdasd"
-    .replace(/\s+/g, " ")
-    .split(" "),
-]);
-
-declare global {
-  var commands: Commands;
-}
-
-globalThis.commands = commands;

package/src/getCommandsFuncs.test.ts

@@ -1,94 +0,0 @@
-import { beforeEach, describe, expect, it } from "bun:test";
-import type { CommandFactory, Commands, CommandsCollection } from "./types";
-import {
-  getAddFooterText,
-  getAddHeaderText,
-  getAddOption,
-  getAddPositionedArgument,
-  getCommands,
-  getGetHelpLine,
-  initCommands,
-  initHelpAndVersion,
-} from "./getCommandsFuncs";
-
-describe("main", () => {
-  let commandsCollection: CommandsCollection;
-  let commands: Commands;
-  let commandFactory: CommandFactory;
-
-  beforeEach(() => {
-    commandsCollection = {};
-    commandFactory = <CommandFactory>(<unknown>{
-      commands: undefined,
-      name: undefined,
-      addAlias: undefined,
-      addOption: undefined,
-      addPositionedArgument: undefined,
-      addDescription: undefined,
-      setCallback: undefined,
-    });
-    commands = initCommands(commandsCollection, undefined, commandFactory);
-  });
-
-  it("getCommands", () => {
-    const commands = getCommands();
-    expect(commands).toBeTruthy;
-  });
-  it("initHelpAndVersion", () => {
-    expect(commandsCollection).not.toHaveProperty("help");
-    expect(commandsCollection).not.toHaveProperty("version");
-    const { helpCallback, versionCallback } = initHelpAndVersion(
-      commands,
-      commandsCollection
-    );
-    expect(commandsCollection).toHaveProperty("help");
-    expect(commandsCollection).toHaveProperty("version");
-
-    expect(helpCallback).not.toThrow();
-    expect(versionCallback).not.toThrow();
-  });
-  it("getAddOption", () => {
-    commands.addCommand("test");
-    const addOption = getAddOption(commandFactory, commandsCollection);
-    addOption("op001");
-    const { test } = commandsCollection;
-    expect(test.options.includes("op001"));
-  });
-  it("getAddPositionedArgument", () => {
-    commands.addCommand("test");
-    const addPositionedArgument = getAddPositionedArgument(
-      commandFactory,
-      commandsCollection
-    );
-
-    addPositionedArgument("pos001");
-    const { test } = commandsCollection;
-
-    expect(test.positionedArguments.includes("pos001"));
-  });
-  it("getAddHeaderText", () => {
-    const addHeaderText = getAddHeaderText(commands);
-    const txt = "test header text...";
-    addHeaderText(txt);
-    expect(commands.headerText).toBe(txt);
-  });
-  it("getAddFooterText", () => {
-    const addFooterText = getAddFooterText(commands);
-    const txt = "test footer text...";
-    addFooterText(txt);
-    expect(commands.footerText).toBe(txt);
-  });
-  it("getGetHelpLine", () => {
-    commands.addCommand("test");
-    const { test } = commandsCollection;
-    const getHelpLine = getGetHelpLine(test);
-    const hl50 = getHelpLine();
-    expect(hl50).toBe("test  ............................................  \n");
-  });
-  it("", () => {
-    commandFactory.commands = <() => Commands>(<unknown>undefined);
-    initCommands(commandsCollection, commands, commandFactory);
-    expect(commandFactory.commands).toBeTruthy;
-    expect(commandFactory.commands).not.toThrow();
-  });
-});

package/src/getStart.test.ts

@@ -1,79 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  mock,
-  spyOn,
-  type Mock,
-} from "bun:test";
-
-import { getStart } from "./getStart";
-import { commandsCollection } from "./testConstants";
-
-describe("getStart", () => {
-  let callback: Mock<any>;
-  let start: (argv?: string[]) => void;
-  let logMock: Mock<any>;
-  let logs: any[] = [];
-
-  beforeEach(() => {
-    callback = mock();
-    commandsCollection.command_1.callback = callback;
-    start = getStart(commandsCollection);
-    logMock = spyOn(console, "log").mockImplementation((...args: any) => {
-      logs.push(args);
-    });
-  });
-  afterEach(() => {
-    callback.mockClear();
-    logMock.mockClear();
-  });
-
-  it("happy path, run command", () => {
-    start(["", "", "command_1"]);
-    expect(callback).toBeCalledTimes(1);
-  });
-  it("run command with option", () => {
-    start(["", "", "command_1", "op1=value1"]);
-    expect(callback).toBeCalledTimes(1);
-  });
-  it("run command with extra positioned arguments", () => {
-    logs = [];
-    start(["", "", "command_1", "pos1", "pos2", "pos3"]);
-    start(["", "", "command_1", "pos1", "pos2", "pos3", "pos4"]);
-    expect(logs).toHaveLength(2);
-    expect(logs[0]).toHaveLength(1);
-    expect(logs[0][0]).toBe("argument 'pos3' not defined");
-    expect(logs[1]).toHaveLength(1);
-    expect(logs[1][0]).toBe("arguments 'pos3, pos4' not defined");
-  });
-  it("run with process.argv", () => {
-    process.argv = ["", ""];
-    start();
-    logs = [];
-    commandsCollection.help.callback();
-    expect(logs).toHaveLength(1);
-  });
-  it("should throw when no args passed", () => {
-    process.argv = <string[]>(<unknown>undefined);
-    expect(start).toThrow(new Error("no arguments passed"));
-  });
-  it("should throw when less than 2 args passed", () => {
-    process.argv = [];
-    expect(start).toThrow(new Error("arguments out of range"));
-  });
-  it("should show message when passed an unexistent commnad", () => {
-    process.argv = ["", "", "fakeCommand"];
-    logs = [];
-    start();
-    expect(logs).toHaveLength(1);
-    expect(logs[0]).toHaveLength(1);
-    expect(logs[0][0]).toBe("command 'fakeCommand' not found");
-  });
-  it("run with less positioned arguments", () => {
-    start(["", "", "al1", "arg001"]);
-    expect(callback).toBeCalledWith({ pos1: "arg001" });
-  });
-});

package/src/textFuncs.test.ts

@@ -1,59 +0,0 @@
-import { command, commands, commandsCollection } from "./testConstants";
-import {
-  buildDescriptionsText,
-  buildHelpText,
-  getCommandText,
-} from "./textFuncs";
-import { describe, expect, it } from "bun:test";
-
-describe("text Functions", () => {
-  describe("getCommandText", () => {
-    it("should return command text", () => {
-      const result = getCommandText(command);
-
-      expect(result).toBe(
-        "command_1|al1|al2   [pos1] [pos2]   [op1=opEx1] [op2=VALUE]  "
-      );
-    });
-
-    it("should return command text without aliases", () => {
-      const result = getCommandText({ ...command, aliases: [] });
-
-      expect(result).toBe(
-        "command_1   [pos1] [pos2]   [op1=opEx1] [op2=VALUE]  "
-      );
-    });
-  });
-  describe("buildHelpText", () => {
-    it("should return help text", () => {
-      const result = buildHelpText(commands, commandsCollection);
-      expect(result).toBe(
-        "\nheader text...\nhelp line...\nhelp line...\nhelp line...\nfooter text...\n"
-      );
-    });
-    it("should return help text without headerText", () => {
-      const result = buildHelpText(
-        { ...commands, headerText: "" },
-        commandsCollection
-      );
-      expect(result).toBe(
-        "\n\nhelp line...\nhelp line...\nhelp line...\nfooter text...\n"
-      );
-    });
-    it("should return help text without footerText", () => {
-      const result = buildHelpText(
-        { ...commands, footerText: "" },
-        commandsCollection
-      );
-      expect(result).toBe(
-        "\nheader text...\nhelp line...\nhelp line...\nhelp line...\n\n"
-      );
-    });
-  });
-  describe("buildDescriptionsText", () => {
-    it("should return description text", () => {
-      const result = buildDescriptionsText(commandsCollection);
-      expect(result).toBe("help line...\n".repeat(3));
-    });
-  });
-});