@jakubmazanec/args 1.0.0-de51f16

package/LICENSE.md

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2023 Jakub Mazanec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+<div align="center">
+
+# @jakubmazanec/args
+
+TypeScript-first library for parsing command line arguments.
+
+</div>
+
+## Installation
+
+```sh
+npm install @jakubmazanec/args
+```
+
+⚠️ This is an [ESM](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c) package!
+It cannot be required from a CommonJS module.
+
+#### Prerequisites
+
+- Node.js 16 or later
+- TypeScript 5 or later
+
+## Usage
+
+Main purpose of this library is to parse command line arguments. Such command line can look like
+this:
+
+```
+┌─ 1 ─┐ ┌─ 2 ──┐ ┌─── 3 ───┐ ┌─── 4 ───┐ ┌─ 5 ─┐ ┌ 6 ┐ ┌─── 7 ───┐    ┌─────── 8 ──────┐
+binname do stuff --key value --key=value -key -K -aBDc foo bar baz -- --key value bar -B
+└───────────────────────────────────────── 9 ──────────────────────────────────────────┘
+```
+
+1. Binary name. This is never passed to the parser.
+2. Command name.
+3. Option with a value. Option name can be in camel case or kebab case.
+4. Another way to specify an option with a value.
+5. Boolean options don't have to specify value to be true. Options can also be defined using a short
+   option form.
+6. Short options group; usually used for boolean options.
+7. Parameters.
+8. Rest arguments appear after the `--`; they are not parsed, but still included in the result.
+9. The whole command line.
+
+The parser is strict and returns fully typed result. You can use it by calling `parseArguments`
+function with the list of arguments and parser configuration:
+
+```TypeScript
+import {parseArguments} from '@jakubmazanec/args';
+
+let {command, parameters, options} = parseArguments(process.argv.slice(2), {
+  commands: ['run', 'build'],
+  parameters: [{
+    description: 'File name',
+    type: 'string',
+    required: true,
+  }],
+  options: {
+    help: {
+      type: 'boolean'
+    }
+  }
+});
+
+console.log(command); // type of `command` is `'run' | 'build' | undefined`
+console.log(parameters); // type of `parameters` is `[string | undefined]`
+console.log(options); // type of `options` is `{help: boolean | undefined}`
+```
+
+See [`ParserConfig`](./docs/README.md#parserconfig) for more information about how to configure the
+parser.
+
+## Documentation
+
+See [API reference](./docs) for auto-generated documentation.
+
+## Contributing
+
+If you want to contribute, see [CONTRIBUTING](./CONTRIBUTING.md) for details.
+
+## License
+
+This package is licensed under the GNU Lesser General Public License v3. See [LICENSE](./LICENSE.md)
+for details.

package/dist/ParsingError.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A subclass of `Error` that indicates a parsing failure.
+ */
+export declare const ParsingError: new (code: "INVALID_PARAMETER" | "UNKNOWN_PARAMETER" | "INVALID_OPTION" | "UNKNOWN_OPTION", options?: import("@jakubmazanec/error").CustomErrorOptions | undefined) => import("@jakubmazanec/error").CustomError<"INVALID_PARAMETER" | "UNKNOWN_PARAMETER" | "INVALID_OPTION" | "UNKNOWN_OPTION" | "UNKNOWN_ERROR">;

package/dist/ParsingError.js

@@ -0,0 +1,11 @@
+import { createCustomError } from '@jakubmazanec/error';
+/**
+ * A subclass of `Error` that indicates a parsing failure.
+ */ export const ParsingError = createCustomError('ParsingError', {
+    INVALID_PARAMETER: 'Invalid value "{0}" found. Allowed values for parameter "{1}" are: {2}.',
+    UNKNOWN_PARAMETER: 'Unknown parameter "{0}" found. Unknown parameters are not allowed.',
+    INVALID_OPTION: 'Invalid value "{0}" found. Allowed values for option "{1}" are: {2}.',
+    UNKNOWN_OPTION: 'Unknown option "{0}" found. Unknown options are not allowed.'
+});
+
+//# sourceMappingURL=ParsingError.js.map

package/dist/ParsingError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ParsingError.ts"],"sourcesContent":["import {createCustomError} from '@jakubmazanec/error';\n\n/**\n * A subclass of `Error` that indicates a parsing failure.\n */\nexport const ParsingError = createCustomError('ParsingError', {\n  INVALID_PARAMETER: 'Invalid value \"{0}\" found. Allowed values for parameter \"{1}\" are: {2}.',\n  UNKNOWN_PARAMETER: 'Unknown parameter \"{0}\" found. Unknown parameters are not allowed.',\n  INVALID_OPTION: 'Invalid value \"{0}\" found. Allowed values for option \"{1}\" are: {2}.',\n  UNKNOWN_OPTION: 'Unknown option \"{0}\" found. Unknown options are not allowed.',\n});\n"],"names":["createCustomError","ParsingError","INVALID_PARAMETER","UNKNOWN_PARAMETER","INVALID_OPTION","UNKNOWN_OPTION"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,sBAAsB;AAEtD;;CAEC,GACD,OAAO,MAAMC,eAAeD,kBAAkB,gBAAgB;IAC5DE,mBAAmB;IACnBC,mBAAmB;IACnBC,gBAAgB;IAChBC,gBAAgB;AAClB,GAAG"}

package/dist/ValidationError.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A subclass of `Error` that indicates a validation issue.
+ */
+export declare const ValidationError: new (code: "INVALID_COMMAND" | "MISSING_PARAMETER" | "INVALID_PARAMETER_DEFAULT_AND_CHOICES" | "INVALID_PARAMETER_ORDER" | "MISSING_OPTION" | "INVALID_OPTION_DEFAULT_AND_CHOICES" | "INVALID_OPTION_NAME" | "REPEATED_OPTION_NAME" | "INVALID_OPTION_ARITY", options?: import("@jakubmazanec/error").CustomErrorOptions | undefined) => import("@jakubmazanec/error").CustomError<"INVALID_COMMAND" | "MISSING_PARAMETER" | "INVALID_PARAMETER_DEFAULT_AND_CHOICES" | "INVALID_PARAMETER_ORDER" | "MISSING_OPTION" | "INVALID_OPTION_DEFAULT_AND_CHOICES" | "INVALID_OPTION_NAME" | "REPEATED_OPTION_NAME" | "INVALID_OPTION_ARITY" | "UNKNOWN_ERROR">;

package/dist/ValidationError.js

@@ -0,0 +1,16 @@
+import { createCustomError } from '@jakubmazanec/error';
+/**
+ * A subclass of `Error` that indicates a validation issue.
+ */ export const ValidationError = createCustomError('ValidationError', {
+    INVALID_COMMAND: 'Command "{0}" has invalid format. Only words consisting of letters, numbers or dashes separated by single space are allowed.',
+    MISSING_PARAMETER: 'Parameter "{0}" is required but its value is undefined.',
+    INVALID_PARAMETER_DEFAULT_AND_CHOICES: 'Parameter "{0}" has invalid default value "{1}". Default value must be one of the `choices` elements.',
+    INVALID_PARAMETER_ORDER: 'Optional parameter "{0}" found before required parameter "{1}". Required parameter must be first.',
+    MISSING_OPTION: 'Option "{0}" is required but its value is undefined.',
+    INVALID_OPTION_DEFAULT_AND_CHOICES: 'Option "{0}" has invalid default value "{1}". Default value must be one of the `choices` elements.',
+    INVALID_OPTION_NAME: 'Option "{0}" has invalid name. Only names consisting of letters, numbers or dashes are allowed.',
+    REPEATED_OPTION_NAME: 'Option "{0}" has invalid short name "{1}". Short option names must be unique.',
+    INVALID_OPTION_ARITY: 'Option "{0}" has invalid number of values. Found "{1}", require "{2}".'
+});
+
+//# sourceMappingURL=ValidationError.js.map

package/dist/ValidationError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ValidationError.ts"],"sourcesContent":["import {createCustomError} from '@jakubmazanec/error';\n\n/**\n * A subclass of `Error` that indicates a validation issue.\n */\nexport const ValidationError = createCustomError('ValidationError', {\n  INVALID_COMMAND:\n    'Command \"{0}\" has invalid format. Only words consisting of letters, numbers or dashes separated by single space are allowed.',\n  MISSING_PARAMETER: 'Parameter \"{0}\" is required but its value is undefined.',\n  INVALID_PARAMETER_DEFAULT_AND_CHOICES:\n    'Parameter \"{0}\" has invalid default value \"{1}\". Default value must be one of the `choices` elements.',\n  INVALID_PARAMETER_ORDER:\n    'Optional parameter \"{0}\" found before required parameter \"{1}\". Required parameter must be first.',\n  MISSING_OPTION: 'Option \"{0}\" is required but its value is undefined.',\n  INVALID_OPTION_DEFAULT_AND_CHOICES:\n    'Option \"{0}\" has invalid default value \"{1}\". Default value must be one of the `choices` elements.',\n  INVALID_OPTION_NAME:\n    'Option \"{0}\" has invalid name. Only names consisting of letters, numbers or dashes are allowed.',\n  REPEATED_OPTION_NAME:\n    'Option \"{0}\" has invalid short name \"{1}\". Short option names must be unique.',\n  INVALID_OPTION_ARITY: 'Option \"{0}\" has invalid number of values. Found \"{1}\", require \"{2}\".',\n});\n"],"names":["createCustomError","ValidationError","INVALID_COMMAND","MISSING_PARAMETER","INVALID_PARAMETER_DEFAULT_AND_CHOICES","INVALID_PARAMETER_ORDER","MISSING_OPTION","INVALID_OPTION_DEFAULT_AND_CHOICES","INVALID_OPTION_NAME","REPEATED_OPTION_NAME","INVALID_OPTION_ARITY"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,sBAAsB;AAEtD;;CAEC,GACD,OAAO,MAAMC,kBAAkBD,kBAAkB,mBAAmB;IAClEE,iBACE;IACFC,mBAAmB;IACnBC,uCACE;IACFC,yBACE;IACFC,gBAAgB;IAChBC,oCACE;IACFC,qBACE;IACFC,sBACE;IACFC,sBAAsB;AACxB,GAAG"}

package/dist/internals/Checker.d.ts

@@ -0,0 +1,13 @@
+import { type CommandsConfig, type OptionsConfig, type ParametersConfig } from '../types.js';
+/**
+ * `Checker` is used for handling various check before, during, and after parsing of the arguments.
+ */
+export declare class Checker {
+    errors: Error[];
+    checkCommandsConfig(commandsConfig: CommandsConfig): void;
+    checkParametersConfig(parametersConfig: ParametersConfig | []): void;
+    checkOptionsConfig(optionsConfig: OptionsConfig): void;
+    checkParsedParameters(parametersConfig: ParametersConfig | [], parsedParameters: unknown[]): void;
+    checkParsedOptions(optionsConfig: OptionsConfig, parsedOptions: Record<string, unknown>): void;
+    addError(error: Error): void;
+}

package/dist/internals/Checker.js

@@ -0,0 +1,118 @@
+import { ValidationError } from '../ValidationError.js';
+import { isCommand } from './isCommand.js';
+import { isLongOption } from './isLongOption.js';
+/**
+ * `Checker` is used for handling various check before, during, and after parsing of the arguments.
+ */ export class Checker {
+    errors = [];
+    checkCommandsConfig(commandsConfig) {
+        for (let commandConfig of commandsConfig){
+            if (!isCommand(commandConfig)) {
+                this.addError(new ValidationError('INVALID_COMMAND', {
+                    messageParameters: [
+                        commandConfig
+                    ]
+                }));
+            }
+        }
+    }
+    checkParametersConfig(parametersConfig) {
+        for (let [i, parameterConfig] of parametersConfig.entries()){
+            var _parametersConfig_;
+            // types of choices must be correct
+            if (parameterConfig.type !== 'boolean' && parameterConfig.choices && // default values and chocies do not contradict each other
+            typeof parameterConfig.defaultValue !== 'undefined' && !parameterConfig.choices.includes(parameterConfig.defaultValue)) {
+                this.addError(new ValidationError('INVALID_PARAMETER_DEFAULT_AND_CHOICES', {
+                    messageParameters: [
+                        parameterConfig.label ?? i,
+                        parameterConfig.defaultValue
+                    ]
+                }));
+            }
+            // if parameter is required, all parameters before must be required too
+            if (i >= 1 && parameterConfig.required === true && ((_parametersConfig_ = parametersConfig[i - 1]) === null || _parametersConfig_ === void 0 ? void 0 : _parametersConfig_.required) !== true) {
+                var _parametersConfig_1;
+                this.addError(new ValidationError('INVALID_PARAMETER_ORDER', {
+                    messageParameters: [
+                        ((_parametersConfig_1 = parametersConfig[i - 1]) === null || _parametersConfig_1 === void 0 ? void 0 : _parametersConfig_1.label) ?? i - 1,
+                        parameterConfig.label ?? i
+                    ]
+                }));
+            }
+        }
+    }
+    checkOptionsConfig(optionsConfig) {
+        let usedShortOptionNames = new Set([]);
+        for (let [optionName, optionConfig] of Object.entries(optionsConfig)){
+            // option names must be in correct format
+            if (!isLongOption(`--${optionName}`)) {
+                this.addError(new ValidationError('INVALID_OPTION_NAME', {
+                    messageParameters: [
+                        optionName
+                    ]
+                }));
+            }
+            // option short names must be unique
+            if (optionConfig.shortName && usedShortOptionNames.has(optionConfig.shortName)) {
+                this.addError(new ValidationError('REPEATED_OPTION_NAME', {
+                    messageParameters: [
+                        optionName,
+                        optionConfig.shortName
+                    ]
+                }));
+            } else if (optionConfig.shortName) {
+                usedShortOptionNames.add(optionConfig.shortName);
+            }
+            // default values and chocies do not contradict each other
+            if ((optionConfig.type === 'string' || optionConfig.type === 'number' && !optionConfig.count) && optionConfig.choices && typeof optionConfig.defaultValue !== 'undefined' && !optionConfig.choices.includes(optionConfig.defaultValue)) {
+                this.addError(new ValidationError('INVALID_OPTION_DEFAULT_AND_CHOICES', {
+                    messageParameters: [
+                        optionName,
+                        optionConfig.defaultValue
+                    ]
+                }));
+            }
+        }
+    }
+    checkParsedParameters(parametersConfig, parsedParameters) {
+        for (let [i, parameterConfig] of parametersConfig.entries()){
+            let parsedParameter = parsedParameters[i];
+            // required parameters must have value
+            if (parameterConfig.required === true && typeof parsedParameter === 'undefined') {
+                this.addError(new ValidationError('MISSING_PARAMETER', {
+                    messageParameters: [
+                        parameterConfig.label ?? i
+                    ]
+                }));
+            }
+        }
+    }
+    checkParsedOptions(optionsConfig, parsedOptions) {
+        for (let [optionName, optionConfig] of Object.entries(optionsConfig)){
+            let parsedOption = parsedOptions[optionName];
+            // check required
+            if (optionConfig.required && typeof parsedOption === 'undefined') {
+                this.addError(new ValidationError('MISSING_OPTION', {
+                    messageParameters: [
+                        optionName
+                    ]
+                }));
+            }
+            // check arity
+            if (typeof parsedOption !== 'undefined' && (optionConfig.type === 'string' && optionConfig.multiple || optionConfig.type === 'number' && optionConfig.multiple) && typeof optionConfig.arity === 'number' && Array.isArray(parsedOption) && parsedOption.length > 0 && parsedOption.length !== optionConfig.arity) {
+                this.addError(new ValidationError('INVALID_OPTION_ARITY', {
+                    messageParameters: [
+                        optionName,
+                        parsedOption.length,
+                        optionConfig.arity
+                    ]
+                }));
+            }
+        }
+    }
+    addError(error) {
+        this.errors.push(error);
+    }
+}
+
+//# sourceMappingURL=Checker.js.map

package/dist/internals/Checker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/Checker.ts"],"sourcesContent":["import {type CommandsConfig, type OptionsConfig, type ParametersConfig} from '../types.js';\nimport {ValidationError} from '../ValidationError.js';\nimport {isCommand} from './isCommand.js';\nimport {isLongOption} from './isLongOption.js';\n\n/**\n * `Checker` is used for handling various check before, during, and after parsing of the arguments.\n */\nexport class Checker {\n  errors: Error[] = [];\n\n  checkCommandsConfig(commandsConfig: CommandsConfig) {\n    for (let commandConfig of commandsConfig) {\n      if (!isCommand(commandConfig)) {\n        this.addError(new ValidationError('INVALID_COMMAND', {messageParameters: [commandConfig]}));\n      }\n    }\n  }\n\n  checkParametersConfig(parametersConfig: ParametersConfig | []) {\n    for (let [i, parameterConfig] of parametersConfig.entries()) {\n      // types of choices must be correct\n      if (\n        parameterConfig.type !== 'boolean' &&\n        parameterConfig.choices && // default values and chocies do not contradict each other\n        typeof parameterConfig.defaultValue !== 'undefined' &&\n        !parameterConfig.choices.includes(parameterConfig.defaultValue as never)\n      ) {\n        this.addError(\n          new ValidationError('INVALID_PARAMETER_DEFAULT_AND_CHOICES', {\n            messageParameters: [parameterConfig.label ?? i, parameterConfig.defaultValue],\n          }),\n        );\n      }\n\n      // if parameter is required, all parameters before must be required too\n      if (\n        i >= 1 &&\n        parameterConfig.required === true &&\n        parametersConfig[i - 1]?.required !== true\n      ) {\n        this.addError(\n          new ValidationError('INVALID_PARAMETER_ORDER', {\n            messageParameters: [\n              parametersConfig[i - 1]?.label ?? i - 1,\n              parameterConfig.label ?? i,\n            ],\n          }),\n        );\n      }\n    }\n  }\n\n  checkOptionsConfig(optionsConfig: OptionsConfig) {\n    let usedShortOptionNames: Set<string> = new Set([]);\n\n    for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {\n      // option names must be in correct format\n      if (!isLongOption(`--${optionName}`)) {\n        this.addError(\n          new ValidationError('INVALID_OPTION_NAME', {\n            messageParameters: [optionName],\n          }),\n        );\n      }\n\n      // option short names must be unique\n      if (optionConfig.shortName && usedShortOptionNames.has(optionConfig.shortName)) {\n        this.addError(\n          new ValidationError('REPEATED_OPTION_NAME', {\n            messageParameters: [optionName, optionConfig.shortName],\n          }),\n        );\n      } else if (optionConfig.shortName) {\n        usedShortOptionNames.add(optionConfig.shortName);\n      }\n\n      // default values and chocies do not contradict each other\n      if (\n        (optionConfig.type === 'string' ||\n          (optionConfig.type === 'number' && !optionConfig.count)) &&\n        optionConfig.choices &&\n        typeof optionConfig.defaultValue !== 'undefined' &&\n        !optionConfig.choices.includes(optionConfig.defaultValue as never)\n      ) {\n        this.addError(\n          new ValidationError('INVALID_OPTION_DEFAULT_AND_CHOICES', {\n            messageParameters: [optionName, optionConfig.defaultValue],\n          }),\n        );\n      }\n    }\n  }\n\n  checkParsedParameters(parametersConfig: ParametersConfig | [], parsedParameters: unknown[]) {\n    for (let [i, parameterConfig] of parametersConfig.entries()) {\n      let parsedParameter = parsedParameters[i];\n\n      // required parameters must have value\n      if (parameterConfig.required === true && typeof parsedParameter === 'undefined') {\n        this.addError(\n          new ValidationError('MISSING_PARAMETER', {\n            messageParameters: [parameterConfig.label ?? i],\n          }),\n        );\n      }\n    }\n  }\n\n  checkParsedOptions(optionsConfig: OptionsConfig, parsedOptions: Record<string, unknown>) {\n    for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {\n      let parsedOption = parsedOptions[optionName];\n\n      // check required\n      if (optionConfig.required && typeof parsedOption === 'undefined') {\n        this.addError(\n          new ValidationError('MISSING_OPTION', {\n            messageParameters: [optionName],\n          }),\n        );\n      }\n\n      // check arity\n      if (\n        typeof parsedOption !== 'undefined' &&\n        ((optionConfig.type === 'string' && optionConfig.multiple) ||\n          (optionConfig.type === 'number' && optionConfig.multiple)) &&\n        typeof optionConfig.arity === 'number' &&\n        Array.isArray(parsedOption) &&\n        (parsedOption as unknown[]).length > 0 &&\n        (parsedOption as unknown[]).length !== optionConfig.arity\n      ) {\n        this.addError(\n          new ValidationError('INVALID_OPTION_ARITY', {\n            messageParameters: [optionName, (parsedOption as unknown[]).length, optionConfig.arity],\n          }),\n        );\n      }\n    }\n  }\n\n  addError(error: Error) {\n    this.errors.push(error);\n  }\n}\n"],"names":["ValidationError","isCommand","isLongOption","Checker","errors","checkCommandsConfig","commandsConfig","commandConfig","addError","messageParameters","checkParametersConfig","parametersConfig","i","parameterConfig","entries","type","choices","defaultValue","includes","label","required","checkOptionsConfig","optionsConfig","usedShortOptionNames","Set","optionName","optionConfig","Object","shortName","has","add","count","checkParsedParameters","parsedParameters","parsedParameter","checkParsedOptions","parsedOptions","parsedOption","multiple","arity","Array","isArray","length","error","push"],"mappings":"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"}

package/dist/internals/CommandScope.d.ts

@@ -0,0 +1,14 @@
+import { type NormalizedCommandConfig, type NormalizedCommandsConfig } from '../types.js';
+/**
+ * `CommandScope` handles storing information about parsing of a command.
+ */
+export declare class CommandScope {
+    private readonly args;
+    readonly config: NormalizedCommandConfig;
+    constructor(arg: string, normalizedCommandsConfig: NormalizedCommandsConfig);
+    captureArg(arg: string): this;
+    isComplete(): boolean;
+    isDone(): boolean;
+    getValue(): string;
+    getArgs(): string[];
+}

package/dist/internals/CommandScope.js

@@ -0,0 +1,48 @@
+/**
+ * `CommandScope` handles storing information about parsing of a command.
+ */ export class CommandScope {
+    args;
+    config;
+    constructor(arg, normalizedCommandsConfig){
+        let normalizedArgument = arg.toLowerCase();
+        let commandConfig = normalizedCommandsConfig.find((commandConfig)=>commandConfig.args[0] === normalizedArgument);
+        this.config = commandConfig ?? [];
+        this.args = [
+            normalizedArgument
+        ];
+    }
+    captureArg(arg) {
+        this.args.push(arg.toLowerCase());
+        return this;
+    }
+    isComplete() {
+        let isComplete = true;
+        for (let [i, arg] of this.config.args.entries()){
+            if (this.args[i] !== arg) {
+                isComplete = false;
+                break;
+            }
+        }
+        return isComplete;
+    }
+    isDone() {
+        let isDone = false;
+        for (let [i, arg] of this.config.args.entries()){
+            if (this.args[i] !== arg) {
+                isDone = true;
+                break;
+            }
+        }
+        return isDone;
+    }
+    getValue() {
+        return this.config.command;
+    }
+    getArgs() {
+        return [
+            ...this.args
+        ];
+    }
+}
+
+//# sourceMappingURL=CommandScope.js.map

package/dist/internals/CommandScope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/CommandScope.ts"],"sourcesContent":["import {type NormalizedCommandConfig, type NormalizedCommandsConfig} from '../types.js';\n\n/**\n * `CommandScope` handles storing information about parsing of a command.\n */\nexport class CommandScope {\n  private readonly args: string[];\n  readonly config: NormalizedCommandConfig;\n\n  constructor(arg: string, normalizedCommandsConfig: NormalizedCommandsConfig) {\n    let normalizedArgument = arg.toLowerCase();\n    let commandConfig = normalizedCommandsConfig.find(\n      (commandConfig) => commandConfig.args[0] === normalizedArgument,\n    );\n\n    this.config = commandConfig ?? ([] as unknown as NormalizedCommandConfig);\n    this.args = [normalizedArgument];\n  }\n\n  captureArg(arg: string) {\n    this.args.push(arg.toLowerCase());\n\n    return this;\n  }\n\n  isComplete() {\n    let isComplete = true;\n\n    for (let [i, arg] of this.config.args.entries()) {\n      if (this.args[i] !== arg) {\n        isComplete = false;\n\n        break;\n      }\n    }\n\n    return isComplete;\n  }\n\n  isDone() {\n    let isDone = false;\n\n    for (let [i, arg] of this.config.args.entries()) {\n      if (this.args[i] !== arg) {\n        isDone = true;\n\n        break;\n      }\n    }\n\n    return isDone;\n  }\n\n  getValue() {\n    return this.config.command;\n  }\n\n  getArgs() {\n    return [...this.args];\n  }\n}\n"],"names":["CommandScope","args","config","constructor","arg","normalizedCommandsConfig","normalizedArgument","toLowerCase","commandConfig","find","captureArg","push","isComplete","i","entries","isDone","getValue","command","getArgs"],"mappings":"AAEA;;CAEC,GACD,OAAO,MAAMA;IACMC,KAAe;IACvBC,OAAgC;IAEzCC,YAAYC,GAAW,EAAEC,wBAAkD,CAAE;QAC3E,IAAIC,qBAAqBF,IAAIG,WAAW;QACxC,IAAIC,gBAAgBH,yBAAyBI,IAAI,CAC/C,CAACD,gBAAkBA,cAAcP,IAAI,CAAC,EAAE,KAAKK;QAG/C,IAAI,CAACJ,MAAM,GAAGM,iBAAkB,EAAE;QAClC,IAAI,CAACP,IAAI,GAAG;YAACK;SAAmB;IAClC;IAEAI,WAAWN,GAAW,EAAE;QACtB,IAAI,CAACH,IAAI,CAACU,IAAI,CAACP,IAAIG,WAAW;QAE9B,OAAO,IAAI;IACb;IAEAK,aAAa;QACX,IAAIA,aAAa,IAAI;QAErB,KAAK,IAAI,CAACC,GAAGT,IAAI,IAAI,IAAI,CAACF,MAAM,CAACD,IAAI,CAACa,OAAO,GAAI;YAC/C,IAAI,IAAI,CAACb,IAAI,CAACY,EAAE,KAAKT,KAAK;gBACxBQ,aAAa,KAAK;gBAElB,KAAM;YACR,CAAC;QACH;QAEA,OAAOA;IACT;IAEAG,SAAS;QACP,IAAIA,SAAS,KAAK;QAElB,KAAK,IAAI,CAACF,GAAGT,IAAI,IAAI,IAAI,CAACF,MAAM,CAACD,IAAI,CAACa,OAAO,GAAI;YAC/C,IAAI,IAAI,CAACb,IAAI,CAACY,EAAE,KAAKT,KAAK;gBACxBW,SAAS,IAAI;gBAEb,KAAM;YACR,CAAC;QACH;QAEA,OAAOA;IACT;IAEAC,WAAW;QACT,OAAO,IAAI,CAACd,MAAM,CAACe,OAAO;IAC5B;IAEAC,UAAU;QACR,OAAO;eAAI,IAAI,CAACjB,IAAI;SAAC;IACvB;AACF,CAAC"}

package/dist/internals/OptionScope.d.ts

@@ -0,0 +1,14 @@
+import { type OptionConfig, type OptionsConfig } from '../types.js';
+/**
+ * `CommandScope` handles storing information about parsing of an option..
+ */
+export declare class OptionScope {
+    name: string;
+    values: unknown[];
+    previousParsedValue?: unknown[] | unknown;
+    readonly config: OptionConfig;
+    constructor(optionName: string, optionsConfig: OptionsConfig, allowUnknownOptions?: boolean);
+    captureArg(arg: string): void;
+    isComplete(): boolean;
+    getValue(): unknown;
+}

package/dist/internals/OptionScope.js

@@ -0,0 +1,87 @@
+import camelCase from 'lodash.camelcase';
+import { ParsingError } from '../ParsingError.js';
+import { castValue } from './castValue.js';
+/**
+ * `CommandScope` handles storing information about parsing of an option..
+ */ export class OptionScope {
+    name;
+    values = [];
+    previousParsedValue;
+    config;
+    constructor(optionName, optionsConfig, allowUnknownOptions = false){
+        this.name = optionName;
+        // Convert option to camel case
+        if (this.name.includes('-')) {
+            this.name = camelCase(this.name);
+        }
+        let optionConfig = optionsConfig[this.name];
+        if (!optionConfig) {
+            if (!allowUnknownOptions) {
+                throw new ParsingError('UNKNOWN_OPTION', {
+                    messageParameters: [
+                        this.name
+                    ]
+                });
+            }
+            optionConfig = {
+                type: 'string'
+            };
+        }
+        this.config = optionConfig;
+    }
+    captureArg(arg) {
+        let value = castValue(arg, this.config.type);
+        if ((this.config.type === 'number' && !this.config.count || this.config.type === 'string') && typeof this.config.choices !== 'undefined' && !this.config.choices.includes(value)) {
+            throw new ParsingError('INVALID_OPTION', {
+                messageParameters: [
+                    value,
+                    this.name,
+                    this.config.choices.map((choice)=>`"${choice}"`).join(', ')
+                ]
+            });
+        }
+        if (this.config.multiple) {
+            this.values.push(value);
+        } else {
+            this.values = [
+                value
+            ];
+        }
+    }
+    isComplete() {
+        if (!this.config.multiple && this.values.length === 1) {
+            return true;
+        }
+        if (this.config.multiple && typeof this.config.arity === 'number' && this.values.length + (this.previousParsedValue ?? []).length === this.config.arity) {
+            return true;
+        }
+        return false;
+    }
+    getValue() {
+        let { config , previousParsedValue  } = this;
+        let { values  } = this;
+        if (config.type === 'boolean' && !config.multiple && !values.length) {
+            values = [
+                true
+            ];
+        } else if (config.type === 'number' && config.count && !values.length) {
+            values = [
+                1
+            ];
+        }
+        if (config.multiple && previousParsedValue) {
+            values = [
+                ...previousParsedValue,
+                ...values
+            ];
+        }
+        if (config.type === 'number' && config.count && previousParsedValue) {
+            values = [
+                values[0] + previousParsedValue
+            ];
+        }
+        return config.multiple ? values : values[0];
+    }
+}
+
+//# sourceMappingURL=OptionScope.js.map

package/dist/internals/OptionScope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/OptionScope.ts"],"sourcesContent":["import camelCase from 'lodash.camelcase';\n\nimport {ParsingError} from '../ParsingError.js';\nimport {type OptionConfig, type OptionsConfig} from '../types.js';\nimport {castValue} from './castValue.js';\n\n/**\n * `CommandScope` handles storing information about parsing of an option..\n */\nexport class OptionScope {\n  name: string;\n\n  values: unknown[] = [];\n  previousParsedValue?: unknown[] | unknown;\n  readonly config: OptionConfig;\n\n  constructor(optionName: string, optionsConfig: OptionsConfig, allowUnknownOptions = false) {\n    this.name = optionName;\n\n    // Convert option to camel case\n    if (this.name.includes('-')) {\n      this.name = camelCase(this.name);\n    }\n\n    let optionConfig = optionsConfig[this.name];\n\n    if (!optionConfig) {\n      if (!allowUnknownOptions) {\n        throw new ParsingError('UNKNOWN_OPTION', {messageParameters: [this.name]});\n      }\n\n      optionConfig = {\n        type: 'string',\n      };\n    }\n\n    this.config = optionConfig;\n  }\n\n  captureArg(arg: string) {\n    let value = castValue(arg, this.config.type);\n\n    if (\n      ((this.config.type === 'number' && !this.config.count) || this.config.type === 'string') &&\n      typeof this.config.choices !== 'undefined' &&\n      !this.config.choices.includes(value as never)\n    ) {\n      throw new ParsingError('INVALID_OPTION', {\n        messageParameters: [\n          value,\n          this.name,\n          this.config.choices.map((choice) => `\"${choice}\"`).join(', '),\n        ],\n      });\n    }\n\n    if (this.config.multiple) {\n      this.values.push(value);\n    } else {\n      this.values = [value];\n    }\n  }\n\n  isComplete() {\n    if (!this.config.multiple && this.values.length === 1) {\n      return true;\n    }\n\n    if (\n      this.config.multiple &&\n      typeof this.config.arity === 'number' &&\n      this.values.length + ((this.previousParsedValue as unknown[] | undefined) ?? []).length ===\n        this.config.arity\n    ) {\n      return true;\n    }\n\n    return false;\n  }\n\n  getValue() {\n    let {config, previousParsedValue} = this;\n    let {values} = this;\n\n    if (config.type === 'boolean' && !config.multiple && !values.length) {\n      values = [true];\n    } else if (config.type === 'number' && config.count && !values.length) {\n      values = [1];\n    }\n\n    if (config.multiple && previousParsedValue) {\n      values = [...(previousParsedValue as unknown[]), ...values];\n    }\n\n    if (config.type === 'number' && config.count && previousParsedValue) {\n      values = [(values[0] as number) + (previousParsedValue as number)];\n    }\n\n    return config.multiple ? values : values[0];\n  }\n}\n"],"names":["camelCase","ParsingError","castValue","OptionScope","name","values","previousParsedValue","config","constructor","optionName","optionsConfig","allowUnknownOptions","includes","optionConfig","messageParameters","type","captureArg","arg","value","count","choices","map","choice","join","multiple","push","isComplete","length","arity","getValue"],"mappings":"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"}

package/dist/internals/castValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A function that casts string value to a specified type.
+ *
+ * @param value The value to be converted.
+ * @param type The type to convert the value into.
+ * */
+export declare function castValue<T extends 'boolean' | 'number' | 'string'>(value: string, type?: T): T extends 'boolean' ? boolean : T extends 'number' ? number : string;

package/dist/internals/castValue.js

@@ -0,0 +1,25 @@
+import { isFalseString } from './isFalseString.js';
+/**
+ * A function that casts string value to a specified type.
+ *
+ * @param value The value to be converted.
+ * @param type The type to convert the value into.
+ * */ export function castValue(value, type) {
+    switch(type){
+        case 'boolean':
+            {
+                let booleanString = String(value).toLowerCase();
+                return !(isFalseString(booleanString) || booleanString === '');
+            }
+        case 'number':
+            {
+                return Number.parseFloat(value);
+            }
+        default:
+            {
+                return String(value);
+            }
+    }
+}
+
+//# sourceMappingURL=castValue.js.map

package/dist/internals/castValue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/castValue.ts"],"sourcesContent":["import {isFalseString} from './isFalseString.js';\n\n/**\n * A function that casts string value to a specified type.\n *\n * @param value The value to be converted.\n * @param type The type to convert the value into.\n * */\nexport function castValue<T extends 'boolean' | 'number' | 'string'>(\n  value: string,\n  type?: T,\n): T extends 'boolean' ? boolean : T extends 'number' ? number : string {\n  switch (type) {\n    case 'boolean': {\n      let booleanString = String(value).toLowerCase();\n\n      return !(isFalseString(booleanString) || booleanString === '') as T extends 'boolean'\n        ? boolean\n        : T extends 'number'\n        ? number\n        : string;\n    }\n\n    case 'number': {\n      return Number.parseFloat(value) as T extends 'boolean'\n        ? boolean\n        : T extends 'number'\n        ? number\n        : string;\n    }\n\n    default: {\n      return String(value) as T extends 'boolean' ? boolean : T extends 'number' ? number : string;\n    }\n  }\n}\n"],"names":["isFalseString","castValue","value","type","booleanString","String","toLowerCase","Number","parseFloat"],"mappings":"AAAA,SAAQA,aAAa,QAAO,qBAAqB;AAEjD;;;;;GAKG,GACH,OAAO,SAASC,UACdC,KAAa,EACbC,IAAQ,EAC8D;IACtE,OAAQA;QACN,KAAK;YAAW;gBACd,IAAIC,gBAAgBC,OAAOH,OAAOI,WAAW;gBAE7C,OAAO,CAAEN,CAAAA,cAAcI,kBAAkBA,kBAAkB,EAAC;YAK9D;QAEA,KAAK;YAAU;gBACb,OAAOG,OAAOC,UAAU,CAACN;YAK3B;QAEA;YAAS;gBACP,OAAOG,OAAOH;YAChB;IACF;AACF,CAAC"}

package/dist/internals/commandToArguments.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A function that converts a string representing a command into the arguments, i.e. array of strings.
+ *
+ * @param value The value to convert.
+ * @return Arguments.
+ */
+export declare function commandToArguments(value: string): string[];

package/dist/internals/commandToArguments.js

@@ -0,0 +1,21 @@
+/**
+ * A function that converts a string representing a command into the arguments, i.e. array of strings.
+ *
+ * @param value The value to convert.
+ * @return Arguments.
+ */ export function commandToArguments(value) {
+    let rawArgs = value.split(' ');
+    let args = [];
+    for (let [, rawValue] of rawArgs.entries()){
+        if (typeof rawValue !== 'undefined') {
+            if (rawValue === '' && args.at(-1)) {
+                args[args.length - 1] += ' ';
+            } else {
+                args.push(rawValue);
+            }
+        }
+    }
+    return args;
+}
+
+//# sourceMappingURL=commandToArguments.js.map

package/dist/internals/commandToArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/commandToArguments.ts"],"sourcesContent":["/**\n * A function that converts a string representing a command into the arguments, i.e. array of strings.\n *\n * @param value The value to convert.\n * @return Arguments.\n */\nexport function commandToArguments(value: string): string[] {\n  let rawArgs = value.split(' ');\n  let args: string[] = [];\n\n  for (let [, rawValue] of rawArgs.entries()) {\n    if (typeof rawValue !== 'undefined') {\n      if (rawValue === '' && args.at(-1)) {\n        args[args.length - 1] += ' ';\n      } else {\n        args.push(rawValue);\n      }\n    }\n  }\n\n  return args;\n}\n"],"names":["commandToArguments","value","rawArgs","split","args","rawValue","entries","at","length","push"],"mappings":"AAAA;;;;;CAKC,GACD,OAAO,SAASA,mBAAmBC,KAAa,EAAY;IAC1D,IAAIC,UAAUD,MAAME,KAAK,CAAC;IAC1B,IAAIC,OAAiB,EAAE;IAEvB,KAAK,IAAI,GAAGC,SAAS,IAAIH,QAAQI,OAAO,GAAI;QAC1C,IAAI,OAAOD,aAAa,aAAa;YACnC,IAAIA,aAAa,MAAMD,KAAKG,EAAE,CAAC,CAAC,IAAI;gBAClCH,IAAI,CAACA,KAAKI,MAAM,GAAG,EAAE,IAAI;YAC3B,OAAO;gBACLJ,KAAKK,IAAI,CAACJ;YACZ,CAAC;QACH,CAAC;IACH;IAEA,OAAOD;AACT,CAAC"}

package/dist/internals/createOptionShortNameMap.d.ts

@@ -0,0 +1,2 @@
+import { type OptionsConfig } from '../types.js';
+export declare function createOptionShortNameMap(optionsConfig: OptionsConfig): Record<string, string>;

package/dist/internals/createOptionShortNameMap.js

@@ -0,0 +1,11 @@
+export function createOptionShortNameMap(optionsConfig) {
+    let map = {};
+    for (let [optionName, optionConfig] of Object.entries(optionsConfig)){
+        if (typeof optionConfig.shortName === 'string') {
+            map[optionConfig.shortName] = optionName;
+        }
+    }
+    return map;
+}
+
+//# sourceMappingURL=createOptionShortNameMap.js.map

package/dist/internals/createOptionShortNameMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/internals/createOptionShortNameMap.ts"],"sourcesContent":["import {type OptionsConfig} from '../types.js';\n\nexport function createOptionShortNameMap(optionsConfig: OptionsConfig) {\n  let map: Record<string, string> = {};\n\n  for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {\n    if (typeof optionConfig.shortName === 'string') {\n      map[optionConfig.shortName] = optionName;\n    }\n  }\n\n  return map;\n}\n"],"names":["createOptionShortNameMap","optionsConfig","map","optionName","optionConfig","Object","entries","shortName"],"mappings":"AAEA,OAAO,SAASA,yBAAyBC,aAA4B,EAAE;IACrE,IAAIC,MAA8B,CAAC;IAEnC,KAAK,IAAI,CAACC,YAAYC,aAAa,IAAIC,OAAOC,OAAO,CAACL,eAAgB;QACpE,IAAI,OAAOG,aAAaG,SAAS,KAAK,UAAU;YAC9CL,GAAG,CAACE,aAAaG,SAAS,CAAC,GAAGJ;QAChC,CAAC;IACH;IAEA,OAAOD;AACT,CAAC"}

package/dist/internals/expandArguments.d.ts

@@ -0,0 +1,8 @@
+import { type Argv } from '../types.js';
+/**
+ * A function that converts any argument that is a short options group into separate short options.
+ *
+ * @param argv Arguments.
+ * @return Arguments that contain no short options group
+ */
+export declare function expandArguments(argv: Argv): Argv;

package/dist/internals/expandArguments.js

@@ -0,0 +1,21 @@
+import { isShortOptionsGroup } from './isShortOptionsGroup.js';
+/**
+ * A function that converts any argument that is a short options group into separate short options.
+ *
+ * @param argv Arguments.
+ * @return Arguments that contain no short options group
+ */ export function expandArguments(argv) {
+    let expandedArguments = [];
+    for (let arg of argv){
+        if (isShortOptionsGroup(arg)) {
+            expandedArguments.push(...[
+                ...arg
+            ].slice(1).map((value)=>`-${value}`));
+        } else {
+            expandedArguments.push(arg);
+        }
+    }
+    return expandedArguments;
+}
+
+//# sourceMappingURL=expandArguments.js.map