Make interactive recursive

Author: fardjad

README.md

@@ -32,39 +32,47 @@ npm install --save interactive-commander
 ```typescript
 import { InteractiveCommand, InteractiveOption } from "interactive-commander";
 
-const program = new InteractiveCommand()
-  // Registers -i, --interactive flags
-  .interactive("-i, --interactive", "interactive mode");
+const program = new InteractiveCommand();
 
 program
   .command("pizza")
-
-  // .option adds a regular (non-interactive) option to the command
+  // Detached options are interactive by default
   .option("-d, --drink", "drink")
 
-  // To create an interactive option, use addOption and pass in a new instance
-  // of InteractiveOption
+  // Missing mandatory options won't throw an error in interactive mode
+  .requiredOption("-o, --olive-oil", "olive oil")
+
+  // Boolean InteractiveOptions will show a confirmation prompt by default
+  .option("-c, --cheese", "cheese")
+  .option("-C, --no-cheese", "no cheese")
+
   .addOption(
     new InteractiveOption("-n, --count <number>", "number of pizzas")
       // InteractiveOption supports all the methods of Commander.js' Option
       .argParser(Number)
       .default(1),
   )
 
-  // Boolean InteractiveOptions will show a confirmation prompt by default
-  .addOption(new InteractiveOption("-c, --cheese", "cheese"))
-  .addOption(new InteractiveOption("-C, --no-cheese", "no cheese"))
+  .addOption(
+    new InteractiveOption(
+      "--non-interactive-option <value>",
+      "non-interactive option",
+    )
+      // Passing in undefined to prompt will disable interactive mode for this option
+      .prompt(undefined)
+      .default("default value"),
+  )
 
   // InteractiveOptions with choices will show a select prompt by default
   .addOption(
     new InteractiveOption("-s, --size <size>", "size")
       .choices(["small", "medium", "large"])
-      // Missing mandatory options won't throw an error in interactive mode
+      .default("medium")
       .makeOptionMandatory(),
   )
 
   .addOption(
-    new InteractiveOption("-n, --name <string>", "your name")
+    new InteractiveOption("-m, --name <string>", "your name")
       // You can use the prompt method to implement your own prompt logic
       .prompt(async (currentValue, option, command) => {
         // TODO: Implement your own prompt logic here
@@ -76,18 +84,24 @@ program
       .makeOptionMandatory(),
   )
 
-  .action((_options, cmd: Command) => {
+  .action((_options, cmd: InteractiveCommand) => {
     console.log("Options: %o", cmd.opts());
   });
 
-await program.parseAsync(process.argv);
+await program
+  // Enables interactive mode (when -i or --interactive is passed in)
+  // This should almost always be called on the root command right before
+  // calling parseAsync
+  .interactive("-i, --interactive", "interactive mode")
+  .parseAsync(process.argv);
 
 // Try the following commands:
 // command-name pizza
 // command-name pizza -i
 // command-name pizza -i --count 2
 // command-name pizza -i --count 2 --no-cheese
 // command-name pizza -i --name "John Doe"
+// command-name pizza -i --name "John Doe" --non-interactive-option abc
 ```
 
 More examples can be found in the [examples](/examples/) directory.

examples/custom-prompt.ts

@@ -0,0 +1,73 @@
+/* eslint-disable no-warning-comments, unicorn/no-useless-undefined */
+import { InteractiveCommand, InteractiveOption } from "../src/index.ts";
+
+const program = new InteractiveCommand();
+
+program
+  .command("pizza")
+  // Detached options are interactive by default
+  .option("-d, --drink", "drink")
+
+  // Missing mandatory options won't throw an error in interactive mode
+  .requiredOption("-o, --olive-oil", "olive oil")
+
+  // Boolean InteractiveOptions will show a confirmation prompt by default
+  .option("-c, --cheese", "cheese")
+  .option("-C, --no-cheese", "no cheese")
+
+  .addOption(
+    new InteractiveOption("-n, --count <number>", "number of pizzas")
+      // InteractiveOption supports all the methods of Commander.js' Option
+      .argParser(Number)
+      .default(1),
+  )
+
+  .addOption(
+    new InteractiveOption(
+      "--non-interactive-option <value>",
+      "non-interactive option",
+    )
+      // Passing in undefined to prompt will disable interactive mode for this option
+      .prompt(undefined)
+      .default("default value"),
+  )
+
+  // InteractiveOptions with choices will show a select prompt by default
+  .addOption(
+    new InteractiveOption("-s, --size <size>", "size")
+      .choices(["small", "medium", "large"])
+      .default("medium")
+      .makeOptionMandatory(),
+  )
+
+  .addOption(
+    new InteractiveOption("-m, --name <string>", "your name")
+      // You can use the prompt method to implement your own prompt logic
+      .prompt(async (currentValue, option, command) => {
+        // TODO: Implement your own prompt logic here
+        const answer = "world";
+
+        // Return the answer
+        return answer;
+      })
+      .makeOptionMandatory(),
+  )
+
+  .action((_options, cmd: InteractiveCommand) => {
+    console.log("Options: %o", cmd.opts());
+  });
+
+await program
+  // Enables interactive mode (when -i or --interactive is passed in)
+  // This should almost always be called on the root command right before
+  // calling parseAsync
+  .interactive("-i, --interactive", "interactive mode")
+  .parseAsync(process.argv);
+
+// Try the following commands:
+// command-name pizza
+// command-name pizza -i
+// command-name pizza -i --count 2
+// command-name pizza -i --count 2 --no-cheese
+// command-name pizza -i --name "John Doe"
+// command-name pizza -i --name "John Doe" --non-interactive-option abc

examples/order-pizza.ts

@@ -1,6 +1,6 @@
 {
   "name": "interactive-commander",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "Commander.js with integrated interactive prompts",
   "keywords": [
     "commander",

examples/simple.ts

@@ -4,8 +4,8 @@ import { Command, Option } from "commander";
 import assert from "node:assert";
 import { test } from "node:test";
 
-await test("interactive flags", async (t) => {
-  await t.test("unset", async () => {
+await test("interactive", async (t) => {
+  await t.test("unset flags", async () => {
     const interactiveCommand = new InteractiveCommand();
 
     assert.deepStrictEqual(interactiveCommand.options, []);
@@ -30,20 +30,42 @@ await test("interactive flags", async (t) => {
     ]);
   });
 
-  await t.test("inheritance", async () => {
-    const parentCommand = new InteractiveCommand().interactive(
-      "-c, --custom",
-      "custom option",
-    );
+  await t.test("nested commands", async () => {
+    const rootCommand = new InteractiveCommand();
 
-    const subCommand = parentCommand.command("sub");
+    const subCommand = rootCommand.command("sub");
 
-    for (const command of [parentCommand, subCommand]) {
+    rootCommand.interactive("-c, --custom", "custom option");
+
+    for (const command of [rootCommand, subCommand]) {
       assert.deepStrictEqual(command.options, [
         new Option("-c, --custom", "custom option"),
       ]);
     }
   });
+
+  await t.test("multiple invokations", async (t) => {
+    const readFunction = t.mock.fn(async () => "value");
+
+    const rootCommand = new InteractiveCommand();
+
+    const subCommand = rootCommand
+      .command("sub")
+      .addOption(
+        new InteractiveOption("-c, --custom <value>", "custom option").prompt(
+          readFunction,
+        ),
+      );
+
+    rootCommand.interactive();
+    rootCommand.interactive();
+
+    await rootCommand.parseAsync(["node", "test", "sub", "-i"]);
+
+    assert.strictEqual(readFunction.mock.calls.length, 1);
+    assert.strictEqual(rootCommand.options.length, 1);
+    assert.strictEqual(subCommand.options.length, 2);
+  });
 });
 
 await test("parse", async (t) => {
@@ -59,10 +81,15 @@ await test("parseAsync", async (t) => {
   let subCommand: InteractiveCommand;
 
   t.beforeEach(() => {
-    rootCommand = new InteractiveCommand().interactive();
-    rootCommand.exitOverride();
+    rootCommand = new InteractiveCommand().configureOutput({
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      outputError() {},
+    });
 
+    rootCommand.exitOverride();
     subCommand = rootCommand.command("sub");
+
+    rootCommand.interactive();
   });
 
   await t.test("interactive sub-command - non-interactive mode", async (t) => {
@@ -80,6 +107,8 @@ await test("parseAsync", async (t) => {
     const nonInteractiveCommand = new Command("non-interactive");
     rootCommand.addCommand(nonInteractiveCommand);
 
+    rootCommand.interactive();
+
     assert.doesNotThrow(async () => {
       await rootCommand.parseAsync(["node", "test", "non-interactive", "-i"]);
     });