cli-kiss 0.2.8 → 0.2.9

package/tests/unit.Reader.shortBig.ts

@@ -1,9 +1,5 @@
 import { expect, it } from "@jest/globals";
-import {
-  ReaderArgs,
-  ReaderOptionNextGuard,
-  ReaderOptionRestGuard,
-} from "../src";
+import { ReaderArgs, ReaderOptionNextGuard } from "../src";
 
 it("run", async function () {
   const stream = new ReaderArgs([
@@ -25,115 +21,108 @@ it("run", async function () {
 
   const kSofUnset = stream.registerOptionShort({
     key: "sof-unset",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
   const kSofNormal = stream.registerOptionShort({
     key: "sof-normal",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
   const kSofPositive = stream.registerOptionShort({
     key: "sof-positive",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
   const kSofNegative = stream.registerOptionShort({
     key: "sof-negative",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
 
   const kAa = stream.registerOptionShort({
     key: "aa",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
   const kBb = stream.registerOptionShort({
     key: "bb",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
   const kCc = stream.registerOptionShort({
     key: "cc",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-1");
 
   const kSovSplit = stream.registerOptionShort({
     key: "sov-split",
-    restGuard: optionValuedRestGuard,
     nextGuard: optionValuedNextGuard,
+    consumeGroupRestAsValue: true,
   });
   const kSovJoin = stream.registerOptionShort({
     key: "sov-join",
-    restGuard: optionValuedRestGuard,
     nextGuard: optionValuedNextGuard,
+    consumeGroupRestAsValue: true,
   });
   const kSovUnset = stream.registerOptionShort({
     key: "sov-unset",
-    restGuard: optionValuedRestGuard,
     nextGuard: optionValuedNextGuard,
+    consumeGroupRestAsValue: true,
   });
 
   const kDd = stream.registerOptionShort({
     key: "dd",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
   const kEe = stream.registerOptionShort({
     key: "ee",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
 
   const kFf = stream.registerOptionShort({
     key: "ff",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
   const kGg = stream.registerOptionShort({
     key: "gg",
-    restGuard: optionFlagRestGuard,
     nextGuard: optionFlagNextGuard,
+    consumeGroupRestAsValue: false,
   });
 
   expect(stream.consumePositional()).toStrictEqual("positional-2");
 
-  expect(kSofUnset().values).toStrictEqual([]);
-  expect(kSofNormal().values).toStrictEqual([{ inlined: null, separated: [] }]);
-  expect(kSofPositive().values).toStrictEqual([
-    { inlined: "true", separated: [] },
-  ]);
-  expect(kSofNegative().values).toStrictEqual([
-    { inlined: "false", separated: [] },
-  ]);
+  expect(kSofUnset()).toStrictEqual([]);
+  expect(kSofNormal()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kSofPositive()).toStrictEqual([{ inlined: "true", separated: [] }]);
+  expect(kSofNegative()).toStrictEqual([{ inlined: "false", separated: [] }]);
 
-  expect(kAa().values).toStrictEqual([{ inlined: null, separated: [] }]);
-  expect(kBb().values).toStrictEqual([{ inlined: null, separated: [] }]);
-  expect(kCc().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kAa()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kBb()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kCc()).toStrictEqual([{ inlined: null, separated: [] }]);
 
-  expect(kSovUnset().values).toStrictEqual([]);
-  expect(kSovSplit().values).toStrictEqual([
+  expect(kSovUnset()).toStrictEqual([]);
+  expect(kSovSplit()).toStrictEqual([
     { inlined: null, separated: ["1.1"] },
     { inlined: null, separated: ["1.2"] },
   ]);
-  expect(kSovJoin().values).toStrictEqual([
+  expect(kSovJoin()).toStrictEqual([
     { inlined: "2.1", separated: [] },
     { inlined: "2.2", separated: [] },
   ]);
 
-  expect(kDd().values).toStrictEqual([{ inlined: null, separated: [] }]);
-  expect(kEe().values).toStrictEqual([{ inlined: null, separated: [] }]);
-  expect(kFf().values).toStrictEqual([{ inlined: null, separated: [] }]);
-  expect(kGg().values).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kDd()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kEe()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kFf()).toStrictEqual([{ inlined: null, separated: [] }]);
+  expect(kGg()).toStrictEqual([{ inlined: null, separated: [] }]);
 });
 
-const optionFlagRestGuard: ReaderOptionRestGuard = () => false;
 const optionFlagNextGuard: ReaderOptionNextGuard = () => false;
-
-const optionValuedRestGuard: ReaderOptionRestGuard = () => true;
 const optionValuedNextGuard: ReaderOptionNextGuard = (value) =>
   value.inlined === null && value.separated.length === 0;

package/tests/unit.command.aliases.ts

@@ -6,7 +6,7 @@ import {
   optionRepeatable,
   optionSingleValue,
   ReaderArgs,
-  type,
+  typeString,
 } from "../src";
 
 it("run", async function () {
@@ -17,7 +17,7 @@ it("run", async function () {
         options: {
           option: optionRepeatable({
             long: "option",
-            type: type(),
+            type: typeString(),
             aliases: {
               longs: ["option-alias1", "option-alias2"],
               shorts: ["pts", "o"],
@@ -25,40 +25,28 @@ it("run", async function () {
           }),
           flag1: optionFlag({
             long: "flag1",
-            aliases: {
-              longs: ["flag1-alias"],
-              shorts: ["fa"],
-            },
+            aliases: { longs: ["flag1-alias"], shorts: ["fa"] },
           }),
           flag2: optionFlag({
             long: "flag2",
-            aliases: {
-              longs: ["flag2-alias"],
-              shorts: ["fb"],
-            },
+            aliases: { longs: ["flag2-alias"], shorts: ["fb"] },
           }),
           weird: optionRepeatable({
             long: "2",
-            aliases: {
-              shorts: ["2o"],
-            },
-            type: type(),
+            aliases: { shorts: ["2o"] },
+            type: typeString(),
           }),
           v1: optionSingleValue({
             long: "v1",
-            aliases: {
-              shorts: ["va"],
-            },
-            type: type(),
+            aliases: { shorts: ["va"] },
+            type: typeString(),
             impliedValueIfNotInlined: () => "bypass",
             fallbackValueIfAbsent: () => undefined,
           }),
           v2: optionSingleValue({
             long: "v2",
-            aliases: {
-              shorts: ["vb"],
-            },
-            type: type(),
+            aliases: { shorts: ["vb"] },
+            type: typeString(),
             impliedValueIfNotInlined: () => "bypass",
             fallbackValueIfAbsent: () => undefined,
           }),

package/tests/unit.command.execute.ts

@@ -12,9 +12,9 @@ import {
   positionalRequired,
   positionalVariadics,
   ReaderArgs,
-  type,
   typeList,
   typeNumber,
+  typeString,
 } from "../src";
 
 const rootCommand = commandChained(
@@ -46,7 +46,7 @@ const rootCommand = commandChained(
         options: {
           string: optionSingleValue({
             long: "string-option",
-            type: type(),
+            type: typeString(),
             fallbackValueIfAbsent: () => undefined,
           }),
           number: optionRepeatable({
@@ -66,7 +66,7 @@ const rootCommand = commandChained(
         operation(
           {
             options: {},
-            positionals: [positionalRequired({ type: type() })],
+            positionals: [positionalRequired({ type: typeString() })],
           },
           async function (context, inputs) {
             return { at: "sub1", context, inputs };
@@ -80,8 +80,8 @@ const rootCommand = commandChained(
             options: {},
             positionals: [
               positionalRequired({ type: typeNumber() }),
-              positionalOptional({ type: type(), default: () => "42" }),
-              positionalVariadics({ type: type() }),
+              positionalOptional({ type: typeString(), default: () => "42" }),
+              positionalVariadics({ type: typeString() }),
             ],
           },
           async function (context, inputs) {

package/tests/unit.command.usage.ts

@@ -12,10 +12,10 @@ import {
   positionalRequired,
   positionalVariadics,
   ReaderArgs,
-  type,
   typeChoice,
   typeList,
   typeNumber,
+  typeString,
   typeTuple,
   TypoSupport,
   usageToStyledLines,
@@ -79,13 +79,13 @@ const rootCommand = commandChained<any, any, any>(
           stringOption: optionSingleValue({
             short: "s",
             long: "string-option",
-            type: type("cool-stuff"),
+            type: typeString("cool-stuff"),
             fallbackValueIfAbsent: () => undefined,
             description: "string-option description",
           }),
           complexOption: optionRepeatable({
             long: "complex-option",
-            type: typeTuple([typeNumber(), typeList(type("string"))]),
+            type: typeTuple([typeNumber(), typeList(typeString("string"))]),
             description: "complex-option description",
           }),
         },
@@ -127,7 +127,7 @@ const rootCommand = commandChained<any, any, any>(
             positionals: [
               positionalRequired({
                 description: "Required positional string",
-                type: type("pos-3.1"),
+                type: typeString("pos-3.1"),
               }),
             ],
           },
@@ -172,14 +172,14 @@ const rootCommand = commandChained<any, any, any>(
             options: {
               duduValue: optionSingleValue({
                 long: "dudu",
-                type: type("dudu-value"),
+                type: typeString("dudu-value"),
                 fallbackValueIfAbsent: () => "duduDefault",
                 hint: "Dudu option hint",
                 description: "Dudu option description",
               }),
               impliable: optionSingleValue({
                 long: "impliable",
-                type: type("text"),
+                type: typeString("text"),
                 impliedValueIfNotInlined: () => "implied",
                 fallbackValueIfAbsent: () => "absent",
               }),
@@ -192,12 +192,12 @@ const rootCommand = commandChained<any, any, any>(
               positionalOptional({
                 description: "Optional positional string",
                 hint: "Optional positional hint",
-                type: type("pos-4"),
+                type: typeString("pos-4"),
                 default: () => "42",
               }),
               positionalVariadics({
                 description: "Variadic positionals strings",
-                type: type("pos-5"),
+                type: typeString("pos-5"),
               }),
             ],
           },

package/tests/unit.runner.cycle.ts

@@ -10,9 +10,9 @@ import {
   positionalRequired,
   positionalVariadics,
   runAndExit,
-  type,
   typeChoice,
-  typeConverted,
+  typeMapped,
+  typeString,
   typeUrl,
 } from "../src";
 
@@ -20,13 +20,15 @@ it("run", async function () {
   const rootUsage = [
     "Usage: my-cli <req1> <subcommand>",
     "",
-    "Root Description",
+    "Root Description (Hint for root)",
+    "Root details1",
+    "Root details2",
     "",
     "Positionals:",
-    "  <req1>  Required1 positional description",
+    "  <req1>  Required1 positional description (Hint for req1)",
     "",
     "Subcommands:",
-    "  sub  Subcommand Description",
+    "  sub  Subcommand Description (Hint for sub)",
     "",
     "Options:",
     "  -ff, --flag[=no]                    Option flag description",
@@ -37,10 +39,12 @@ it("run", async function () {
   const subUsage = [
     "Usage: my-cli <req1> sub <req2> [optional] [variadic]...",
     "",
-    "Subcommand Description",
+    "Subcommand Description (Hint for sub)",
+    "Sub details1",
+    "Sub details2",
     "",
     "Positionals:",
-    "  <req1>         Required1 positional description",
+    "  <req1>         Required1 positional description (Hint for req1)",
     "  <req2>         Required2 positional description",
     "  [optional]     Optional positional description",
     "  [variadic]...  Variadics positional description",
@@ -123,14 +127,14 @@ it("run", async function () {
     [],
     [
       rootUsage,
-      "Error: <req1>: Is required, but was not provided. (Required1 positional description)",
+      "Error: Missing argument: <req1>: Required1 positional description (Hint for req1)",
     ],
     1,
   );
   await testCase(
     ["req1"],
     [],
-    [rootUsage, "Error: <subcommand>: Missing argument. Did you mean: sub ?"],
+    [rootUsage, "Error: Missing argument: <subcommand>. Did you mean: sub ?"],
     1,
   );
   await testCase(
@@ -138,7 +142,7 @@ it("run", async function () {
     [],
     [
       subUsage,
-      "Error: <req2>: Is required, but was not provided. (Required2 positional description)",
+      "Error: Missing argument: <req2>: Required2 positional description",
     ],
     1,
   );
@@ -167,7 +171,7 @@ it("run", async function () {
     [],
     [
       subUsage,
-      "Error: <req2>: Is required, but was not provided. (Required2 positional description)",
+      "Error: Missing argument: <req2>: Required2 positional description",
     ],
     1,
   );
@@ -252,7 +256,7 @@ it("run", async function () {
   await testCase(
     ["invalid"],
     [],
-    [rootUsage, "Error: <subcommand>: Missing argument. Did you mean: sub ?"],
+    [rootUsage, "Error: Missing argument: <subcommand>. Did you mean: sub ?"],
     1,
   );
   await testCase(
@@ -407,7 +411,11 @@ async function testCase(
   ]);
   const onExit = makeMocked<number, never>([null as never]);
   const cmd = commandWithSubcommands<null, void, void>(
-    { description: "Root Description" },
+    {
+      description: "Root Description",
+      hint: "Hint for root",
+      details: ["Root details1", "Root details2"],
+    },
     operation(
       {
         options: {
@@ -419,13 +427,13 @@ async function testCase(
           optionRepeatable: optionRepeatable({
             long: "repeatable",
             short: "r",
-            type: type(),
+            type: typeString(),
             description: "Option repeatable description",
           }),
           optionSingleValue: optionSingleValue({
             long: "single-value",
             short: "s",
-            type: typeConverted(
+            type: typeMapped(
               "enum(number)",
               typeChoice("enum(string)", ["42", "43"]),
               (value) => Number(value),
@@ -438,6 +446,7 @@ async function testCase(
           positionalRequired({
             type: typeChoice("req1", ["req1", "req1-bis"]),
             description: "Required1 positional description",
+            hint: "Hint for req1",
           }),
         ],
       },
@@ -447,7 +456,11 @@ async function testCase(
     ),
     {
       sub: command(
-        { description: "Subcommand Description" },
+        {
+          description: "Subcommand Description",
+          hint: "Hint for sub",
+          details: ["Sub details1", "Sub details2"],
+        },
         operation(
           {
             options: {
@@ -464,12 +477,12 @@ async function testCase(
                 description: "Required2 positional description",
               }),
               positionalOptional({
-                type: type("optional"),
+                type: typeString("optional"),
                 description: "Optional positional description",
                 default: () => "world !",
               }),
               positionalVariadics({
-                type: type("variadic"),
+                type: typeString("variadic"),
                 description: "Variadics positional description",
               }),
             ],