@cloud-copilot/cli 0.1.39 → 0.2.1

package/README.md

@@ -7,59 +7,103 @@
 Utilities for standardizing working CLIs in Typescript.
 
 - Standardizes the way subcommands, arguments, and operands are parsed and validated
-- Includes "fuzzy matching" of subcommands and arguments, so users can provide partial names if they match only one subcommand or argument
+- Includes "prefix matching" of subcommands and arguments, so users can provide partial names if they match only one subcommand or argument
 - Allows users to default arguments with environment variables
 - Automatically generates a help text for the user
 - Provides a type safe response of the parsed arguments
 - Has zero dependencies
+- Built-in argument types for string, number, boolean, enum, array, and map types
+- Easy custom argument types to create your own argument types with validation
+- Async argument validation and version checking
+- Automatic version checking for updates to your CLI
 
 I wrote this because I'm building several CLI applications and want to have a standard parsing of arguments that users can rely on across all of them.
 
 I was inspired by https://github.com/lirantal/nodejs-cli-apps-best-practices and https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap12.html to follow best practices for accepting arguments and environment variables while keeping my scope extremely limited and having no dependencies.
 
+## Table of Contents
+
+- [Example](#example)
+- [Installation](#installation)
+- [Documentation](#documentation)
+  - [Core Guides](#core-guides)
+  - [Examples](#examples)
+
+## Documentation
+
+### Core Guides
+
+- **[Getting Started](docs/GettingStarted.md)** - Complete tutorial for new users
+- **[Parsing Reference](docs/ParsingReference.md)** - Detailed parsing rules and mechanics
+- **[Subcommands Guide](docs/SubcommandsGuide.md)** - Building CLIs with subcommands
+- **[Custom Arguments](docs/CustomArguments.md)** - Creating custom argument types with validation
+- **[Environment Variables](docs/EnvironmentVariables.md)** - Environment variable integration
+- **[Version Handling](docs/VersionHandling.md)** - Version management and update checking
+- **[API Reference](docs/APIReference.md)** - API documentation
+
+### [Examples](src/demo/README.md)
+
+- **[Basic CLI](src/demo/basic.ts)** - Minimal CLI setup with version handling
+- **[Arguments Demo](src/demo/arguments.ts)** - All argument types including custom date arguments
+- **[Subcommands Demo](src/demo/subcommands.ts)** - CLI with multiple subcommands and arguments
+- **[Version Handling](src/demo/version.ts)** - Version checking and update notifications
+- **[Reading from stdin](src/demo/stdin.ts)** - Processing input from stdin
+
 ## Example
 
 ```typescript
-import {parseCliArguments} from '@cloud-copilot/cli';
-
-const cli = parseArguments(
+import {
+  parseCliArguments,
+  stringArgument,
+  stringArrayArgument,
+  booleanArgument,
+  numberArgument,
+  enumArgument
+} from '@cloud-copilot/cli'
+
+const cli = await parseCliArguments(
   'my-command',
   // optional subcommands
-  init: {
-    description: 'Initialize the project',
-    // Subcommand Specific Arguments
-    options: {
-      s3: {
-        description: 'Use S3 as the storage',
-        character: 's',
-        values: 'none'
-      },
-      language: {
-        description: 'The language to use',
-        values: 'single',
-        type: 'enum',
-        validValues: ['typescript', 'javascript']
+  {
+    init: {
+      description: 'Initialize the project',
+      // Subcommand Specific Arguments
+      arguments: {
+        s3: booleanArgument({
+          description: 'Use S3 as the storage',
+          character: 's'
+        }),
+        language: enumArgument({
+          description: 'The language to use',
+          validValues: ['typescript', 'javascript']
+        })
       }
-    }
-  },
-  download: {
-    description: 'Download a file',
-    // Subcommand Specific Arguments
-    options: {
-      url: {
-        description: 'The URL to download from',
-        values: 'single',
-        type: 'string'
+    },
+    download: {
+      description: 'Download a file',
+      // Subcommand Specific Arguments
+      arguments: {
+        url: stringArgument({
+          description: 'The URL to download from'
+        })
       }
     }
   },
-  // Global Arguments
+  // Global Arguments that apply to all subcommands
   {
-    regions: { type: 'string', values: 'multiple', description: 'Regions to deploy to' },
-    account: { type: 'string', values: 'single', description: 'AWS account to deploy to' },
-    ssl: { values: 'none', description: 'Enable SSL', character: 's', default: false },
-    port: { type: 'number', values: 'single', description: 'Port to use' },
-    points: { type: 'number', values: 'multiple', description: 'Data points' }
+    regions: stringArrayArgument({
+      description: 'Regions to deploy to'
+    }),
+    account: stringArgument({
+      description: 'AWS account to deploy to'
+    }),
+    ssl: booleanArgument({
+      description: 'Enable SSL',
+      character: 's'
+    }),
+    port: numberArgument({
+      description: 'Port to use'
+    })
   },
   {}
 )
@@ -68,18 +112,22 @@ const cli = parseArguments(
 This will automatically pull in the arguments from the command line and validate them. If any arguments are not valid, it will throw an error with the message of what is wrong. If all arguments and subcommands are valid, it will return an object with a type safe response.
 
 ```typescript
-cli.subcommand // string | undefined
-cli.args.regions // string[]
+cli.subcommand // 'init' | 'download' | undefined
+cli.args.regions // string[] | undefined
 cli.args.account // string | undefined
 cli.args.ssl // boolean
 cli.args.port // number | undefined
-cli.args.points // number[]
 
 cli.anyValues // boolean, whether any values were provided on the CLI
 
 if (cli.subcommand === 'init') {
-  // Type Checked command specific arguments
+  // Type Checked command specific arguments only in the return type if the subcommand is selected
   cli.args.s3 // boolean
+  cli.args.language // 'typescript' | 'javascript' | undefined
+}
+
+if (cli.subcommand === 'download') {
+  cli.args.url // string | undefined
 }
 ```
 
@@ -90,172 +138,3 @@ If the user provides `--help` a help message will be printed out with the availa
 ```bash
 npm install @cloud-copilot/cli
 ```
-
-## Parsing CLI Input
-
-Arguments are parsed into three things:
-
-```bash
-my-command [subcommand] [arguments] [--] [operands]
-```
-
-- The subcommand which is the first argument and is optional based on your configuration
-- The arguments that start with `--` (or optionally `-` for boolean flags) in the CLI
-- The operands, which are the remaining values after the arguments. If provided, all arguments after the literal `  --  ` are considered operands.
-
-### Parsing subcommands
-
-If you provide a list of subcommands, the first argument will be parsed as a subcommand if it does not start with a `-`. If the subcommand is not provided, it will be `undefined`.
-
-Partial matching will be used. If only one subcommand matches the string from the user input, the subcommand it matches will be returned. If more than one subcommand matches, an error will be thrown. If the string provided does not match any subcommand, an error will be thrown.
-
-### Parsing Arguments
-
-Arguments are parsed from the CLI input. They are generally parsed as `--name value` or `--name value1 value2 value3`. If the argument is a boolean flag, it can be provided as `--name` or `-n`. Arguments are case insensitive.
-
-#### Boolean Arguments
-
-Boolean values can be provided as `--name` or `-n`. If the argument is a boolean, the value will be `true` if the argument is provided and `false` if it is not. If an argument is passed to a boolean argument, an error will be thrown.
-
-Multiple single character boolean flags can be combined into a single argument. For example, `-abc` is equivalent to `-a -b -c`.
-
-#### String or Number Arguments
-
-String or number arguments can be provided as `--name value` or `--name value1 value2 value3`. If the argument is a single value, it will be parsed as a single value. If the argument is multiple values, it will be parsed as an array of strings or numbers.
-
-String or number arguments will throw an error if:
-
-- The flag is specified and no values are provided
-- The argument accepts only one value and multiple values are provided
-- The argument is a number and a non-number value is provided
-
-#### Enum Arguments
-
-Enum arguments can be provided as `--name value1 value2`. The values must be one of the values provided in the `values` field of the argument configuration. The values are returned as a string or a string array.
-
-Enum arguments will throw an error if:
-
-- The flag is specified and no values are provided
-- The argument accepts only one value and multiple values are provided
-- Any of the arguments provided are not in the list of allowed values.
-
-If the value is not one of the values provided, an error will be thrown.
-
-### Operands
-
-Operands are the remaining values after the arguments.
-If there are no arguments, all strings after the subcommand (if any) are considered operands.
-If the last argument is a boolean all strings after the boolean are considered operands.
-If the last argument is a single value all the strings after the value for the argument are considered operands.
-If the last argument is multiple values, use `  --  ` to separate the arguments from the operands.
-
-### Environment Variables
-
-If an `environmentPrefix` is specified in `additionalArgs`, the library will look for environment variables that start with the prefix and use them as defaults for the arguments. For example, if the prefix is `MY_APP`, the library will look for environment variables like `MY_APP_REGIONS`, `MY_APP_ACCOUNT`, etc. These variables will be validated just like the CLI arguments. Any values provided on the CLI will override the environment variables.
-
-## Printing Help
-
-If the user provides `--help` as an argument the library will print out a help message with the available subcommands and arguments. This can also be done manually with the function `printHelpContents` which accepts the same arguments as `parseCliArguments`.
-
-```typescript
-//Given this config
-parseCliArguments(
-  'my-command',
-  // optional commands
-  [
-    { name: 'init', description: 'Initialize my environment' },
-    {
-      name: 'execute',
-      description: 'Run the download'
-    }
-  ],
-  {
-    expandAsterisk: {
-      character: 'e',
-      description: 'Expand a single wildcard asterisk (*) to all possible values',
-      values: 'none'
-    },
-    invalidActionBehavior: {
-      description: 'Behavior when an invalid action is encountered, defaults to remove',
-      validValues: ['remove', 'error', 'include'],
-      type: 'enum',
-      values: 'single'
-    },
-    readWaitMs: {
-      description: 'Milliseconds to wait between read operations',
-      type: 'number',
-      values: 'single'
-    }
-  },
-  {
-    operandsName: 'action'
-  }
-)
-```
-
-````
-
-```bash
-$ my-command --help
-Usage: my-command [command] [options] [flags] [--] [action1] [action2]
-Commands:
-  init   : Initialize my environment
-  execute: Run the download
-Options:
-  --expand-asterisk:         (-e) Expand a single wildcard asterisk (*) to all possible values.
-  --invalid-action-behavior:      Behavior when an invalid action is encountered, defaults to remove. Must
-                                  be one of: remove, error, include.
-  --read-wait-ms:                 Milliseconds to wait between read operations. One number required
-  --help:                         Print this help message and exit
-````
-
-## API
-
-`parseCliArguments` and `printHelpContents` are the two main functions for arguments and help text. They take the same arguments.
-
-- `commandName` - The name of the command. This is used in the help text.
-- `subcommands` - An object or sub commands that can be provided. The key is the name of the subcommand and the value is the configuration. Can be an empty object `{}`.
-  - `description` - The description of the subcommand. This is used in the help text.
-  - `options` - An object of argument definitions. The key is the name of the argument that will be returned in your results and the value is the configuration. Option objects are the same as described in `cliOptions`
-- `cliOptions` - An object of argument definitions. The key is the name of the argument that will be returned in your results and the value is the configuration. One of
-
-  - Standard Argument:
-
-    - `values` - The number of values the argument accepts. Can be `single` or `multiple`.
-    - `type` - The type of the argument. Can be `string` or `number`.
-    - `description` - The description of the argument. This is used in the help text.
-
-  - Enum Argument:
-
-    - `values` - The number of values the argument accepts. Can be `single` or `multiple`.
-    - `type` - The type of the argument. Must be `enum`.
-    - `validValues` - An array of valid values for the argument.
-    - `description` - The description of the argument. This is used in the help text.
-
-  - Boolean Argument:
-
-    - `character` - The single character flag for the argument.
-    - `type` - The type of the argument. Must be `boolean`.
-    - `description` - The description of the argument. This is used in the help text.
-
-- `additionalArgs` - An object of additional arguments. This can include:
-
-  - `version` - The version of the command. If this is provided the argument `--version` will print out the version and exit.
-  - `args` - Override the string array or arguments to parse, by default it will use `process.argv.slice(2)`.
-  - `env` - Override the environment variables to use, by default it will use `process.env`.
-  - `envPrefix` - A prefix to use for environment variables. If provided, the library will look for environment variables that start with the prefix and use them as defaults for the arguments. For example, if the prefix is `MY_APP`, the library will look for environment variables like `MY_APP_REGIONS`, `MY_APP_ACCOUNT`, etc. These variables will be validated just like the CLI arguments. Any values provided on the CLI will override the environment variables.
-  - `operandsName` - The name of the operands. This is used in the help text. By default, this is `operand`.
-  - `requireSubcommand` - If true, a subcommand is required. By default, this is false.
-  - `allowOperandsFromStdin` - If true, the help text will include a usage example of reading operands from stdin. By default, this is false.
-
-## Reading from stdin
-
-The function `readStdin` can be used to read from stdin. It returns a promise that resolves with the string read from stdin.
-
-```typescript
-import { readStdin } from '@cloud-copilot/cli'
-
-const stdin = await readStdin(undefined)
-```
-
-It optionally takes a read timeout in milliseconds to wait to receive the first byte before it assumes there is no input. This is useful if for instance your CLI is being piped input from another process that may more than a few seconds, such as a `curl` command to an API.

package/dist/cjs/arguments/argument.d.ts

@@ -0,0 +1,60 @@
+export type ValidValue<T> = {
+    valid: true;
+    value: T;
+};
+export type InvalidValue = {
+    valid: false;
+    message: string;
+};
+export type ValidatedValues<T> = ValidValue<T> | InvalidValue;
+export type Argument<ArgumentType> = {
+    /**
+     * A description of the argument, used in help text.
+     */
+    description: string;
+    /**
+     * The default value of the argument, if any.
+     * If not provided, the argument will be undefined until a value is provided.
+     */
+    defaultValue: ArgumentType;
+    /**
+     * Validate all values passed to the argument at once.
+     * @param values the array of strings passed to the argument
+     * @returns if the value is invalid, returns { valid: false, message: string } and message will be shown to the user.
+     *          if the value is valid, returns { valid: true, values`: ArgumentType[] } where value is the parsed value.
+     */
+    validateValues: (currentValue: ArgumentType, values: string[]) => Promise<ValidValue<ArgumentType> | InvalidValue> | ValidValue<ArgumentType> | InvalidValue;
+    /**
+     * Reduces the current value and a new values into a single value.
+     *
+     * @param current the current value of the argument, can be undefined if there is no default value
+     * @param newValues the new values being added as parsed by validateValues
+     * @returns the new value of the argument
+     */
+    reduceValues: (currentValue: ArgumentType, newValues: NonNullable<ArgumentType>) => Promise<ArgumentType> | ArgumentType;
+    /**
+     * If this callback is provided, it will be called when the argument is present
+     *
+     * @param currentValue the current value of the argument
+     * @returns the value to set the argument to
+     */
+    present?(currentValue: ArgumentType): Promise<ArgumentType> | ArgumentType;
+    /**
+     * If this function is provided, it will be called to determine if the argument
+     * can accept multiple values.
+     *
+     * If not provided, the argument will only accept a single value.
+     *
+     * @returns true if the argument can accept multiple values, false otherwise
+     */
+    acceptMultipleValues?(): boolean;
+    /**
+     * A single-character alias for the argument, e.g. 'f' for --foo
+     *
+     * This is only valid if the argument does not take a value (e.g. boolean flags).
+     */
+    character?: string;
+};
+export type PerArgumentArgs = Pick<Argument<any>, 'description'>;
+export type CustomArgument<ArgumentType> = Omit<Argument<ArgumentType>, 'character'>;
+//# sourceMappingURL=argument.d.ts.map

package/dist/cjs/arguments/argument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../src/arguments/argument.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAA;AACrD,MAAM,MAAM,YAAY,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAC5D,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,YAAY,CAAA;AAE7D,MAAM,MAAM,QAAQ,CAAC,YAAY,IAAI;IACnC;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,YAAY,EAAE,YAAY,CAAA;IAE1B;;;;;OAKG;IACH,cAAc,EAAE,CACd,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,EAAE,KACb,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;IAE/F;;;;;;OAMG;IACH,YAAY,EAAE,CACZ,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,WAAW,CAAC,YAAY,CAAC,KACjC,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;IAEzC;;;;;OAKG;IACH,OAAO,CAAC,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;IAE1E;;;;;;;OAOG;IACH,oBAAoB,CAAC,IAAI,OAAO,CAAA;IAEhC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,CAAA;AAChE,MAAM,MAAM,cAAc,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,CAAA"}

package/dist/cjs/arguments/argument.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=argument.js.map

package/dist/cjs/arguments/argument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.js","sourceRoot":"","sources":["../../../src/arguments/argument.ts"],"names":[],"mappings":""}

package/dist/cjs/arguments/arrayValueArgument.d.ts

@@ -0,0 +1,15 @@
+import { Argument, PerArgumentArgs, ValidatedValues } from './argument.js';
+type ArrayValueValidator<ValueType> = (rawValue: string) => Promise<ValidatedValues<ValueType>> | ValidatedValues<ValueType>;
+/**
+ * Creates an array value argument factory for a specific type
+ */
+export declare function arrayValueArgument<ValueType>(validator: ArrayValueValidator<ValueType>, descriptionSuffix?: string): {
+    <const O extends {
+        defaultValue: ValueType[];
+    } & PerArgumentArgs>(options: O): Argument<ValueType[]>;
+    <const O extends {
+        defaultValue?: undefined;
+    } & PerArgumentArgs>(options: O): Argument<ValueType[] | undefined>;
+};
+export {};
+//# sourceMappingURL=arrayValueArgument.d.ts.map

package/dist/cjs/arguments/arrayValueArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayValueArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/arrayValueArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE1E,KAAK,mBAAmB,CAAC,SAAS,IAAI,CACpC,QAAQ,EAAE,MAAM,KACb,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,CAAA;AAErE;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAC1C,SAAS,EAAE,mBAAmB,CAAC,SAAS,CAAC,EACzC,iBAAiB,GAAE,MAAW;WAEA,CAAC,SAAS;QAAE,YAAY,EAAE,SAAS,EAAE,CAAA;KAAE,GAAG,eAAe,WAC5E,CAAC,GACT,QAAQ,CAAC,SAAS,EAAE,CAAC;WACM,CAAC,SAAS;QAAE,YAAY,CAAC,EAAE,SAAS,CAAA;KAAE,GAAG,eAAe,WAC3E,CAAC,GACT,QAAQ,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC;EAsCrC"}

package/dist/cjs/arguments/arrayValueArgument.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayValueArgument = arrayValueArgument;
+/**
+ * Creates an array value argument factory for a specific type
+ */
+function arrayValueArgument(validator, descriptionSuffix = '') {
+    function createArgument(options) {
+        return {
+            description: options.description + descriptionSuffix,
+            validateValues: async (current, values) => {
+                if (values.length === 0) {
+                    return { valid: false, message: 'at least one value is required' };
+                }
+                const validatedValues = [];
+                for (const rawValue of values) {
+                    const result = await validator(rawValue);
+                    if (!result.valid) {
+                        return result;
+                    }
+                    validatedValues.push(result.value);
+                }
+                return { valid: true, value: validatedValues };
+            },
+            reduceValues: async (current, newValues) => {
+                if (!current) {
+                    return newValues;
+                }
+                current.push(...newValues);
+                return current;
+            },
+            defaultValue: options.defaultValue,
+            acceptMultipleValues: () => true
+        };
+    }
+    return createArgument;
+}
+//# sourceMappingURL=arrayValueArgument.js.map

package/dist/cjs/arguments/arrayValueArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayValueArgument.js","sourceRoot":"","sources":["../../../src/arguments/arrayValueArgument.ts"],"names":[],"mappings":";;AASA,gDA+CC;AAlDD;;GAEG;AACH,SAAgB,kBAAkB,CAChC,SAAyC,EACzC,oBAA4B,EAAE;IAQ9B,SAAS,cAAc,CAErB,OAAU;QACV,OAAO;YACL,WAAW,EAAE,OAAO,CAAC,WAAW,GAAG,iBAAiB;YACpD,cAAc,EAAE,KAAK,EACnB,OAAgC,EAChC,MAAgB,EACuB,EAAE;gBACzC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACxB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,gCAAgC,EAAE,CAAA;gBACpE,CAAC;gBAED,MAAM,eAAe,GAAgB,EAAE,CAAA;gBACvC,KAAK,MAAM,QAAQ,IAAI,MAAM,EAAE,CAAC;oBAC9B,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,QAAQ,CAAC,CAAA;oBACxC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;wBAClB,OAAO,MAAM,CAAA;oBACf,CAAC;oBACD,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;gBACpC,CAAC;gBAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,eAAe,EAAE,CAAA;YAChD,CAAC;YACD,YAAY,EAAE,KAAK,EAAE,OAAgC,EAAE,SAAsB,EAAE,EAAE;gBAC/E,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO,SAAS,CAAA;gBAClB,CAAC;gBACD,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,CAAA;gBAC1B,OAAO,OAAO,CAAA;YAChB,CAAC;YACD,YAAY,EAAE,OAAO,CAAC,YAAY;YAClC,oBAAoB,EAAE,GAAG,EAAE,CAAC,IAAI;SACjC,CAAA;IACH,CAAC;IAED,OAAO,cAAc,CAAA;AACvB,CAAC"}

package/dist/cjs/arguments/booleanArgument.d.ts

@@ -0,0 +1,11 @@
+import { Argument, PerArgumentArgs } from './argument.js';
+/**
+ * Creates a boolean argument that is false by default and true if present.
+ *
+ * @param options the description and the single character that can be used to set the value to true
+ * @returns a boolean argument
+ */
+export declare function booleanArgument<const O extends {
+    character: string;
+} & PerArgumentArgs>(options: O): Argument<boolean>;
+//# sourceMappingURL=booleanArgument.d.ts.map

package/dist/cjs/arguments/booleanArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleanArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/booleanArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAmB,MAAM,eAAe,CAAA;AAE1E;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,CAAC,CAAC,SAAS;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,eAAe,EACrF,OAAO,EAAE,CAAC,GACT,QAAQ,CAAC,OAAO,CAAC,CAcnB"}

package/dist/cjs/arguments/booleanArgument.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanArgument = booleanArgument;
+/**
+ * Creates a boolean argument that is false by default and true if present.
+ *
+ * @param options the description and the single character that can be used to set the value to true
+ * @returns a boolean argument
+ */
+function booleanArgument(options) {
+    return {
+        description: options.description,
+        character: options.character,
+        validateValues: (currentValue, value) => {
+            if (value.length == 0) {
+                return { valid: true, value: true };
+            }
+            return { valid: false, message: `does not accept values but received ${value.join(', ')}` };
+        },
+        reduceValues: (current, newValue) => current,
+        present: (currentValue) => true,
+        defaultValue: false
+    };
+}
+//# sourceMappingURL=booleanArgument.js.map

package/dist/cjs/arguments/booleanArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleanArgument.js","sourceRoot":"","sources":["../../../src/arguments/booleanArgument.ts"],"names":[],"mappings":";;AAQA,0CAgBC;AAtBD;;;;;GAKG;AACH,SAAgB,eAAe,CAC7B,OAAU;IAEV,OAAO;QACL,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,cAAc,EAAE,CAAC,YAAqB,EAAE,KAAe,EAA4B,EAAE;YACnF,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACtB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;YACrC,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,uCAAuC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAA;QAC7F,CAAC;QACD,YAAY,EAAE,CAAC,OAAgB,EAAE,QAAiB,EAAE,EAAE,CAAC,OAAO;QAC9D,OAAO,EAAE,CAAC,YAAqB,EAAE,EAAE,CAAC,IAAI;QACxC,YAAY,EAAE,KAAK;KACpB,CAAA;AACH,CAAC"}

package/dist/cjs/arguments/enumArgument.d.ts

@@ -0,0 +1,15 @@
+import { Argument, PerArgumentArgs } from './argument.js';
+type EnumType<T extends {
+    validValues: string[];
+    defaultValue?: string | undefined;
+}> = T['defaultValue'] extends string ? T['validValues'][number] | T['defaultValue'] : T['validValues'][number];
+export declare function enumArgument<const O extends {
+    defaultValue: string;
+    validValues: string[];
+} & PerArgumentArgs>(options: O): Argument<EnumType<O>>;
+export declare function enumArgument<const O extends {
+    defaultValue?: undefined;
+    validValues: string[];
+} & PerArgumentArgs>(options: O): Argument<EnumType<O> | undefined>;
+export {};
+//# sourceMappingURL=enumArgument.d.ts.map

package/dist/cjs/arguments/enumArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/enumArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAmB,MAAM,eAAe,CAAA;AAE1E,KAAK,QAAQ,CAAC,CAAC,SAAS;IAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,IAClF,CAAC,CAAC,cAAc,CAAC,SAAS,MAAM,GAC5B,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC,GAC5C,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9B,wBAAgB,YAAY,CAC1B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACjF,OAAO,EAAE,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AACpC,wBAAgB,YAAY,CAC1B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,CAAC,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACrF,OAAO,EAAE,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA"}

package/dist/cjs/arguments/enumArgument.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumArgument = enumArgument;
+function enumArgument(options) {
+    return {
+        description: options.description +
+            `. One value required, valid values are: ${options.validValues.join(', ')}`,
+        validateValues: (currentValue, values) => {
+            if (values.length == 0) {
+                return { valid: false, message: 'a value is required' };
+            }
+            if (currentValue != options.defaultValue) {
+                return { valid: false, message: 'expects a single values but was set multiple times' };
+            }
+            if (values.length > 1) {
+                return {
+                    valid: false,
+                    message: 'expects a single value but received ' + values.join(', ')
+                };
+            }
+            const value = values[0];
+            const match = options.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
+            if (!match) {
+                return {
+                    valid: false,
+                    message: `${value} is not one of the allowed values: ${options.validValues.join(', ')}`
+                };
+            }
+            return { valid: true, value: match };
+        },
+        reduceValues: (current, newValue) => newValue,
+        defaultValue: options.defaultValue
+    };
+}
+//# sourceMappingURL=enumArgument.js.map

package/dist/cjs/arguments/enumArgument.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumArgument.js","sourceRoot":"","sources":["../../../src/arguments/enumArgument.ts"],"names":[],"mappings":";;AAaA,oCAqCC;AArCD,SAAgB,YAAY,CAE1B,OAAU;IACV,OAAO;QACL,WAAW,EACT,OAAO,CAAC,WAAW;YACnB,2CAA2C,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QAC7E,cAAc,EAAE,CACd,YAAqC,EACrC,MAAgB,EACc,EAAE;YAChC,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACvB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,CAAA;YACzD,CAAC;YACD,IAAI,YAAY,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBACzC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,oDAAoD,EAAE,CAAA;YACxF,CAAC;YACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACtB,OAAO;oBACL,KAAK,EAAE,KAAK;oBACZ,OAAO,EAAE,sCAAsC,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;iBACpE,CAAA;YACH,CAAC;YACD,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;YACvB,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC,CAAA;YACtF,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO;oBACL,KAAK,EAAE,KAAK;oBACZ,OAAO,EAAE,GAAG,KAAK,sCAAsC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;iBACxF,CAAA;YACH,CAAC;YAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAoB,EAAE,CAAA;QACrD,CAAC;QACD,YAAY,EAAE,CAAC,OAAgC,EAAE,QAAqB,EAAE,EAAE,CAAC,QAAQ;QACnF,YAAY,EAAE,OAAO,CAAC,YAAY;KACnC,CAAA;AACH,CAAC"}

package/dist/cjs/arguments/enumArrayArgument.d.ts

@@ -0,0 +1,15 @@
+import { Argument, PerArgumentArgs } from './argument.js';
+type EnumArrayType<T extends {
+    validValues: string[];
+    defaultValue?: string[] | undefined;
+}> = T['defaultValue'] extends string[] ? T['validValues'][number] | T['defaultValue'][number] : T['validValues'][number];
+export declare function enumArrayArgument<const O extends {
+    defaultValue: string[];
+    validValues: string[];
+} & PerArgumentArgs>(options: O): Argument<EnumArrayType<O>[]>;
+export declare function enumArrayArgument<const O extends {
+    defaultValue?: undefined;
+    validValues: string[];
+} & PerArgumentArgs>(options: O): Argument<EnumArrayType<O>[] | undefined>;
+export {};
+//# sourceMappingURL=enumArrayArgument.d.ts.map

package/dist/cjs/arguments/enumArrayArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumArrayArgument.d.ts","sourceRoot":"","sources":["../../../src/arguments/enumArrayArgument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAmB,MAAM,eAAe,CAAA;AAE1E,KAAK,aAAa,CAAC,CAAC,SAAS;IAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAAE,IACzF,CAAC,CAAC,cAAc,CAAC,SAAS,MAAM,EAAE,GAC9B,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,GACpD,CAAC,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9B,wBAAgB,iBAAiB,CAC/B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACnF,OAAO,EAAE,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;AAC3C,wBAAgB,iBAAiB,CAC/B,KAAK,CAAC,CAAC,SAAS;IAAE,YAAY,CAAC,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,eAAe,EACrF,OAAO,EAAE,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,CAAA"}

package/dist/cjs/arguments/enumArrayArgument.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumArrayArgument = enumArrayArgument;
+function enumArrayArgument(options) {
+    return {
+        description: options.description +
+            `. One or more values required, valid values are: ${options.validValues.join(', ')}`,
+        validateValues: async (currentValue, values) => {
+            if (values.length == 0) {
+                return { valid: false, message: 'At least one value is required' };
+            }
+            const invalidValues = [];
+            const validValues = [];
+            for (const value of values) {
+                const match = options.validValues.find((v) => v.toLowerCase() === value.toLowerCase());
+                if (!match) {
+                    invalidValues.push(value);
+                }
+                else {
+                    validValues.push(match);
+                }
+            }
+            if (invalidValues.length > 0) {
+                return {
+                    valid: false,
+                    message: `${invalidValues.map((v) => `${v}`).join(', ')} is not one of the allowed values: ${options.validValues.join(', ')}`
+                };
+            }
+            return { valid: true, value: validValues };
+        },
+        reduceValues: async (current, newValues) => {
+            if (!current) {
+                return newValues;
+            }
+            current.push(...newValues);
+            return current;
+        },
+        defaultValue: options.defaultValue,
+        acceptMultipleValues: () => true
+    };
+}
+//# sourceMappingURL=enumArrayArgument.js.map