cli-kiss 0.2.2 → 0.2.4

package/tests/unit.command.usage.ts

@@ -2,6 +2,7 @@ import { it } from "@jest/globals";
 import {
   command,
   Command,
+  commandChained,
   commandWithSubcommands,
   operation,
   optionFlag,
@@ -19,10 +20,16 @@ import {
   usageToStyledLines,
 } from "../src";
 
-const cmd = commandWithSubcommands<string, any, any>(
+const rootCommand = commandChained<any, any, any>(
   {
     description: "Root command description",
-    details: ["Root command details.", "Second line of root command details."],
+    details: ["Root command details.", "Root second line of command details."],
+    examples: [
+      {
+        explanation: "Example usage of the root command",
+        commandArgs: [{ positional: "42" }, { option: { short: "b" } }],
+      },
+    ],
   },
   operation(
     {
@@ -30,20 +37,7 @@ const cmd = commandWithSubcommands<string, any, any>(
         booleanFlag: optionFlag({
           short: "b",
           long: "boolean-flag",
-          description: "Root boolean-flag description",
-        }),
-        stringOption: optionSingleValue({
-          short: "s",
-          long: "string-option",
-          type: typeString,
-          default: () => undefined,
-          label: "COOL-STUFF",
-          description: "Root string-option description",
-        }),
-        complexOption: optionRepeatable({
-          long: "complex-option",
-          type: typeTuple([typeNumber, typeList(typeString)]),
-          description: "Root complex-option description",
+          description: "boolean-flag description",
         }),
       },
       positionals: [
@@ -52,107 +46,193 @@ const cmd = commandWithSubcommands<string, any, any>(
           description: "Required positional number 1",
           type: typeNumber,
         }),
-        positionalRequired({
-          label: "POS-2",
-          description: "Required positional number 2",
-          type: typeNumber,
-        }),
       ],
     },
-    async (context, inputs) => {
+    async function (context, inputs) {
       return { at: "root", context, inputs };
     },
   ),
-  {
-    sub1: command(
-      {
-        description: "Subcommand 1 description",
-        details: [
-          "Subcommand 1 details.",
-          "Second line of subcommand 1 details.",
-        ],
-      },
-      operation(
+  commandWithSubcommands<any, any, any>(
+    {
+      description: "Mid command description",
+      details: ["Mid command details.", "Mid second line of command details."],
+      examples: [
         {
-          options: {},
-          positionals: [
-            positionalRequired({
-              label: "POS-STRING",
-              description: "Required positional string",
-              type: typeString,
-            }),
+          explanation: "Example usage of the mid command",
+          commandArgs: [
+            { positional: "42" },
+            { option: { short: "b" } },
+            { positional: "43" },
           ],
         },
-        async (context, inputs) => {
-          return { at: "sub1", context, inputs };
-        },
-      ),
-    ),
-    sub2: command(
+      ],
+    },
+    operation(
       {
-        description: "Subcommand 2 description",
-        hint: "Subcommand 2 hint",
-        details: [
-          "Subcommand 2 details.",
-          "Second line of subcommand 2 details.",
+        options: {
+          stringOption: optionSingleValue({
+            short: "s",
+            long: "string-option",
+            type: typeString,
+            default: () => undefined,
+            label: "COOL-STUFF",
+            description: "string-option description",
+          }),
+          complexOption: optionRepeatable({
+            long: "complex-option",
+            type: typeTuple([typeNumber, typeList(typeString)]),
+            description: "complex-option description",
+          }),
+        },
+        positionals: [
+          positionalRequired({
+            label: "POS-2",
+            description: "Required positional number 2",
+            type: typeNumber,
+          }),
         ],
       },
-      operation(
+      async function (context, inputs) {
+        return { at: "root", context, inputs };
+      },
+    ),
+    {
+      sub1: command(
         {
-          options: {
-            duduValue: optionSingleValue({
-              long: "dudu",
-              type: typeString,
-              default: () => "duduDefault",
-              hint: "Dudu option hint",
-              description: "Dudu option description",
-            }),
-          },
-          positionals: [
-            positionalRequired({
-              label: "POS-NUMBER",
-              description: "Required positional number",
-              type: typeNumber,
-            }),
-            positionalOptional({
-              label: "OPT-POS",
-              description: "Optional positional string",
-              hint: "Optional positional hint",
-              type: typeString,
-              default: () => "42",
-            }),
-            positionalVariadics({
-              label: "VARIADIC",
-              description: "Variadic positionals strings",
-              type: typeString,
-            }),
+          description: "Subcommand 1 description",
+          details: [
+            "Subcommand 1 details.",
+            "Subcommand 1 second line of details.",
+          ],
+          examples: [
+            {
+              explanation: "Example usage of subcommand 1",
+              commandArgs: [
+                { option: { short: "b" } },
+                { positional: "42" },
+                { positional: "43" },
+                { subcommand: "sub1" },
+                { positional: "valid" },
+              ],
+            },
           ],
         },
-        async (context, inputs) => {
-          return { at: "sub2", context, inputs };
+        operation(
+          {
+            options: {},
+            positionals: [
+              positionalRequired({
+                label: "POS-STRING",
+                description: "Required positional string",
+                type: typeString,
+              }),
+            ],
+          },
+          async function (context, inputs) {
+            return { at: "sub1", context, inputs };
+          },
+        ),
+      ),
+      sub2: command(
+        {
+          description: "Subcommand 2 description",
+          hint: "Subcommand 2 hint",
+          details: [
+            "Subcommand 2 details.",
+            "Subcommand 2 second line of details.",
+          ],
+          examples: [
+            {
+              explanation: "Example usage of subcommand 2",
+              commandArgs: [
+                { positional: "40" },
+                { positional: "41" },
+                { subcommand: "sub2" },
+                { option: { long: "dudu", value: "hello" } },
+                { positional: "50" },
+              ],
+            },
+          ],
         },
+        operation(
+          {
+            options: {
+              duduValue: optionSingleValue({
+                long: "dudu",
+                type: typeString,
+                default: () => "duduDefault",
+                hint: "Dudu option hint",
+                description: "Dudu option description",
+              }),
+            },
+            positionals: [
+              positionalRequired({
+                label: "POS-NUMBER",
+                description: "Required positional number",
+                type: typeNumber,
+              }),
+              positionalOptional({
+                label: "OPT-POS",
+                description: "Optional positional string",
+                hint: "Optional positional hint",
+                type: typeString,
+                default: () => "42",
+              }),
+              positionalVariadics({
+                label: "VARIADIC",
+                description: "Variadic positionals strings",
+                type: typeString,
+              }),
+            ],
+          },
+          async function (context, inputs) {
+            return { at: "sub2", context, inputs };
+          },
+        ),
       ),
-    ),
-  },
+    },
+  ),
 );
 
-it("run", async () => {
-  const usage1 = await getUsage([], cmd);
-  const usage2 = await getUsage(["50", "51", "sub1"], cmd);
-  const usage3 = await getUsage(["40", "41", "sub2", "--doesn't-exist"], cmd);
-
-  /*
-  console.log(usage1.join("\n"));
-  console.log(usage2.join("\n"));
-  console.log(usage3.join("\n"));
-   */
+it("run", async function () {
+  const usage1 = await getUsage([], rootCommand);
+  const usage2 = await getUsage(["50"], rootCommand);
+  const usage3 = await getUsage(["50", "51"], rootCommand);
+  const usage4 = await getUsage(["50", "51", "sub1"], rootCommand);
+  const usage5 = await getUsage(["50", "51", "sub1", "valid"], rootCommand);
+  const usage6 = await getUsage(
+    ["40", "41", "sub2", "--doesn't-exist"],
+    rootCommand,
+  );
+  const usage7 = await getUsage(
+    ["40", "41", "sub2", "not-a-number"],
+    rootCommand,
+  );
 
-  expect(usage1).toStrictEqual([
-    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{<POS-2>}@darkBlue}+ {{<SUBCOMMAND>}@darkBlue}+",
+  const usageRoot = [
+    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{[REST]...}@darkBlue}+",
     "",
     "{Root command description}+",
     "{{Root command details.}-}*",
-    "{{Second line of root command details.}-}*",
+    "{{Root second line of command details.}-}*",
+    "",
+    "{{Positionals:}@darkGreen}+",
+    "  {{<POS-1>}@darkBlue}+  Required positional number 1",
+    "",
+    "{{Options:}@darkGreen}+",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*  boolean-flag description",
+    "",
+    "{{Examples:}@darkGreen}+",
+    " {{# Example usage of the root command}-}*",
+    " {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+",
+    "",
+  ];
+  const usageMid = [
+    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{<POS-2>}@darkBlue}+ {{<SUBCOMMAND>}@darkBlue}+",
+    "",
+    "{Mid command description}+",
+    "{{Mid command details.}-}*",
+    "{{Mid second line of command details.}-}*",
     "",
     "{{Positionals:}@darkGreen}+",
     "  {{<POS-1>}@darkBlue}+  Required positional number 1",
@@ -163,17 +243,21 @@ it("run", async () => {
     "  {{sub2}@darkCyan}+  Subcommand 2 description {{(Subcommand 2 hint)}-}*",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           Root boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  Root string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  Root complex-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
     "",
-  ]);
-  expect(usage2).toStrictEqual([
+    "{{Examples:}@darkGreen}+",
+    " {{# Example usage of the mid command}-}*",
+    " {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+ {{43}@darkBlue}+",
+    "",
+  ];
+  const usageSub1 = [
     "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{<POS-2>}@darkBlue}+ {{sub1}@darkCyan}+ {{<POS-STRING>}@darkBlue}+",
     "",
     "{Subcommand 1 description}+",
     "{{Subcommand 1 details.}-}*",
-    "{{Second line of subcommand 1 details.}-}*",
+    "{{Subcommand 1 second line of details.}-}*",
     "",
     "{{Positionals:}@darkGreen}+",
     "  {{<POS-1>}@darkBlue}+       Required positional number 1",
@@ -181,17 +265,21 @@ it("run", async () => {
     "  {{<POS-STRING>}@darkBlue}+  Required positional string",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           Root boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  Root string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  Root complex-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
+    "",
+    "{{Examples:}@darkGreen}+",
+    " {{# Example usage of subcommand 1}-}*",
+    " {{my-cli}@darkCyan}+ {{-b}@darkCyan}+ {{42}@darkBlue}+ {{43}@darkBlue}+ {{sub1}@darkCyan}+ {{valid}@darkBlue}+",
     "",
-  ]);
-  expect(usage3).toStrictEqual([
+  ];
+  const usageSub2 = [
     "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{<POS-2>}@darkBlue}+ {{sub2}@darkCyan}+ {{<POS-NUMBER>}@darkBlue}+ {{[OPT-POS]}@darkBlue}+ {{[VARIADIC]...}@darkBlue}+",
     "",
     "{Subcommand 2 description}+ {{(Subcommand 2 hint)}-}*",
     "{{Subcommand 2 details.}-}*",
-    "{{Second line of subcommand 2 details.}-}*",
+    "{{Subcommand 2 second line of details.}-}*",
     "",
     "{{Positionals:}@darkGreen}+",
     "  {{<POS-1>}@darkBlue}+        Required positional number 1",
@@ -201,12 +289,34 @@ it("run", async () => {
     "  {{[VARIADIC]...}@darkBlue}+  Variadic positionals strings",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           Root boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  Root string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  Root complex-option description",
-    "      {{--dudu}@darkCyan}+ {{<STRING>}@darkBlue}+                               Dudu option description {{(Dudu option hint)}-}*",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
+    "      {{--dudu}@darkCyan}+ {{<STRING>}@darkBlue}+                                   Dudu option description {{(Dudu option hint)}-}*",
     "",
-  ]);
+    "{{Examples:}@darkGreen}+",
+    " {{# Example usage of subcommand 2}-}*",
+    " {{my-cli}@darkCyan}+ {{40}@darkBlue}+ {{41}@darkBlue}+ {{sub2}@darkCyan}+ {{--dudu}@darkCyan}+{{=}-}*{{hello}@darkBlue}+ {{50}@darkBlue}+",
+    "",
+  ];
+
+  /*
+  console.log(usage1.join("\n"));
+  console.log(usage2.join("\n"));
+  console.log(usage3.join("\n"));
+  console.log(usage4.join("\n"));
+  console.log(usage5.join("\n"));
+  console.log(usage6.join("\n"));
+  console.log(usage7.join("\n"));
+   */
+
+  expect(usage1).toStrictEqual(usageRoot);
+  expect(usage2).toStrictEqual(usageMid);
+  expect(usage3).toStrictEqual(usageMid);
+  expect(usage4).toStrictEqual(usageSub1);
+  expect(usage5).toStrictEqual(usageSub1);
+  expect(usage6).toStrictEqual(usageSub2);
+  expect(usage7).toStrictEqual(usageSub2);
 });
 
 async function getUsage<Context, Result>(
@@ -214,10 +324,21 @@ async function getUsage<Context, Result>(
   command: Command<Context, Result>,
 ) {
   const readerArgs = new ReaderArgs(args);
-  const commandFactory = command.createFactory(readerArgs);
+  const commandDecoder = command.consumeAndMakeDecoder(readerArgs);
+  /*
+  try {
+    const interpreter = commandDecoder.decodeAndMakeInterpreter();
+    const result = await interpreter.executeWithContext(
+      "" as unknown as Context,
+    );
+    console.log(result);
+  } catch (error) {
+    console.log(TypoSupport.tty().computeStyledErrorMessage(error));
+  }
+    */
   return usageToStyledLines({
     cliName: "my-cli",
-    commandUsage: commandFactory.generateUsage(),
+    usage: commandDecoder.generateUsage(),
     typoSupport: TypoSupport.mock(),
   });
 }

package/tests/unit.runner.cycle.ts

@@ -10,16 +10,13 @@ import {
   positionalRequired,
   positionalVariadics,
   runAndExit,
-  typeConverted,
+  typeMapped,
   typeOneOf,
   typeString,
   typeUrl,
 } from "../src";
 
-// TODO - unit test for chained commands
-// TODO - unit test for errors styling
-
-it("run", async () => {
+it("run", async function () {
   const rootUsage = [
     "Usage: my-cli <REQUIRED1> <SUBCOMMAND>",
     "",
@@ -33,7 +30,7 @@ it("run", async () => {
     "",
     "Options:",
     "  --flag[=no]                   Option flag description",
-    "  --repeatable <STRING>         Option repeatable description",
+    "  --repeatable <STRING> [*]     Option repeatable description",
     "  --single-value <NUMBER-ENUM>  Option single value description",
     "",
   ].join("\n");
@@ -50,9 +47,9 @@ it("run", async () => {
     "",
     "Options:",
     "  --flag[=no]                   Option flag description",
-    "  --repeatable <STRING>         Option repeatable description",
+    "  --repeatable <STRING> [*]     Option repeatable description",
     "  --single-value <NUMBER-ENUM>  Option single value description",
-    "  --url <URL>                   Option url description",
+    "  --url <URL> [*]               Option url description",
     "",
   ].join("\n");
 
@@ -104,7 +101,7 @@ it("run", async () => {
   await testCase(
     ["--invalid1", "--invalid2", "required1", "--invalid3"],
     [],
-    [rootUsage, "Error: --invalid1: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --invalid1"],
     1,
   );
   await testCase(
@@ -138,13 +135,13 @@ it("run", async () => {
   await testCase(
     ["--url", "https://example.com"],
     [],
-    [rootUsage, "Error: --url: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --url"],
     1,
   );
   await testCase(
     ["required1", "--url", "https://example.com"],
     [],
-    [rootUsage, "Error: --url: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --url"],
     1,
   );
   await testCase(
@@ -190,13 +187,13 @@ it("run", async () => {
   await testCase(
     ["--invalid", "required1", "subcommand", "required2"],
     [],
-    [rootUsage, "Error: --invalid: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --invalid"],
     1,
   );
   await testCase(
     ["required1", "subcommand", "required2", "--nope"],
     [],
-    [subcommandUsage, "Error: --nope: Unexpected unknown option"],
+    [subcommandUsage, "Error: Unexpected unknown option: --nope"],
     1,
   );
   await testCase(
@@ -218,7 +215,31 @@ it("run", async () => {
     1,
   );
 
-  // Test invalid positional type value
+  // Test invalid positional type value (should keep parsing best-effort even on invalid values)
+  await testCase(
+    ["invalid"],
+    [],
+    [rootUsage, "Error: <SUBCOMMAND>: Is required, but was not provided"],
+    1,
+  );
+  await testCase(
+    ["invalid", "subcommand"],
+    [],
+    [
+      subcommandUsage,
+      'Error: <REQUIRED1>: STRING-ENUM: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+    ],
+    1,
+  );
+  await testCase(
+    ["invalid", "subcommand", "required2"],
+    [],
+    [
+      subcommandUsage,
+      'Error: <REQUIRED1>: STRING-ENUM: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+    ],
+    1,
+  );
   await testCase(
     ["required1", "subcommand", "invalid"],
     [],
@@ -228,6 +249,15 @@ it("run", async () => {
     ],
     1,
   );
+  await testCase(
+    ["invalid", "subcommand", "invalid"],
+    [],
+    [
+      subcommandUsage,
+      'Error: <REQUIRED1>: STRING-ENUM: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+    ],
+    1,
+  );
 
   // Test root command option invalid values (must not block parsing)
   await testCase(
@@ -253,7 +283,7 @@ it("run", async () => {
   await testCase(
     ["--url", "not-a-url", "required1", "subcommand", "required2"],
     [],
-    [rootUsage, "Error: --url: Unexpected unknown option"],
+    [rootUsage, "Error: Unexpected unknown option: --url"],
     1,
   );
   await testCase(
@@ -326,7 +356,7 @@ async function testCase(
           }),
           optionSingleValue: optionSingleValue({
             long: "single-value",
-            type: typeConverted(typeOneOf("STRING-ENUM", ["42", "43"]), {
+            type: typeMapped(typeOneOf("STRING-ENUM", ["42", "43"]), {
               content: "NUMBER-ENUM",
               decoder: (value) => Number(value),
             }),
@@ -336,13 +366,13 @@ async function testCase(
         },
         positionals: [
           positionalRequired({
-            type: typeString,
+            type: typeOneOf("STRING-ENUM", ["required1", "required1-bis"]),
             label: "REQUIRED1",
             description: "Required1 positional description",
           }),
         ],
       },
-      async () => {
+      async function () {
         console.log("Has executed root command");
       },
     ),
@@ -377,7 +407,7 @@ async function testCase(
               }),
             ],
           },
-          async () => {
+          async function () {
             console.log("Has executed subcommand");
           },
         ),
@@ -405,7 +435,7 @@ function makeMocked<P, R>(returns: Array<R>) {
   const history = new Array<P>();
   return {
     history,
-    call: (p: P) => {
+    call(p: P) {
       history.push(p);
       if (history.length > returns.length) {
         throw new Error(

package/tests/unit.runner.errors.ts

@@ -10,15 +10,31 @@ import {
   typeUrl,
 } from "../src";
 
-it("run", async () => {
+it("run", async function () {
   await testCase(
     ["hello"],
     '{{Error:}@darkRed}+ Unexpected argument: {{"hello"}@darkYellow}+',
   );
+  await testCase(
+    ["--nope"],
+    "{{Error:}@darkRed}+ Unexpected unknown option: {{--nope}@darkYellow}+",
+  );
   await testCase(
     ["--flag", "--flag"],
     "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set multiple times",
   );
+  await testCase(
+    ["--flag", "--no-flag"],
+    "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set in combination with: {{--no-flag}@darkCyan}+",
+  );
+  await testCase(
+    ["--no-flag", "--no-flag"],
+    "{{Error:}@darkRed}+ {{--no-flag}@darkCyan}+: Must not be set multiple times",
+  );
+  await testCase(
+    ["--single-value=a", "--single-value=b"],
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a single value, but got multiple",
+  );
   await testCase(
     ["--flag=invalid"],
     '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{<BOOLEAN>}@darkBlue}+: {{Boolean}@darkMagenta}+: Invalid value: {{"invalid"}@darkYellow}+',
@@ -59,7 +75,7 @@ async function testCase(args: Array<string>, error: string) {
         },
         positionals: [],
       },
-      async () => {},
+      async function () {},
     ),
   );
   console.log = onLogStdOut.call;
@@ -79,7 +95,7 @@ function makeMocked<P, R>(returns: Array<R>) {
   const history = new Array<P>();
   return {
     history,
-    call: (p: P) => {
+    call(p: P) {
       history.push(p);
       if (history.length > returns.length) {
         throw new Error(