@jakubmazanec/args 1.0.3-unstable.feec6e4 → 2.0.0-next.2fa8a2c

package/dist/internals/isOptionLike.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internals/isOptionLike.ts"],"sourcesContent":["const OPTION_LIKE = /^-{1,2}[a-z][-a-z0-9]*=?/iu;\n\n/**\n * A function that checks if a value is an argument that looks like a long option, short option, or a short options group i.e. one or two dashes and a single word consisting only of letters, numbers (but not at the start of the word) or dashes, optionally followed by `=`.\n *\n * @param value The value to check.\n * @return `true` if `value` is an option.\n */\nexport function isOptionLike(value: string): boolean {\n  return OPTION_LIKE.test(value);\n}\n"],"names":["OPTION_LIKE","isOptionLike","value","test"],"mappings":"AAAA,MAAMA,cAAc;AAEpB;;;;;CAKC,GACD,OAAO,SAASC,aAAaC,KAAa;IACxC,OAAOF,YAAYG,IAAI,CAACD;AAC1B"}

package/dist/internals/isShortOption.js

@@ -1,11 +0,0 @@
-const SHORT_OPTION_REGEXP = /^-[a-z]{1}$/iu;
-/**
- * A function that checks if a value is an argument that looks like a short option, i.e. a dash and a single letter; e.g. `'-x'`.
- *
- * @param value The value to check.
- * @return `true` if `value` is a short option.
- */ export function isShortOption(arg) {
-    return SHORT_OPTION_REGEXP.test(arg);
-}
-
-//# sourceMappingURL=isShortOption.js.map

package/dist/internals/isShortOption.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internals/isShortOption.ts"],"sourcesContent":["const SHORT_OPTION_REGEXP = /^-[a-z]{1}$/iu;\n\n/**\n * A function that checks if a value is an argument that looks like a short option, i.e. a dash and a single letter; e.g. `'-x'`.\n *\n * @param value The value to check.\n * @return `true` if `value` is a short option.\n */\nexport function isShortOption(arg: string): boolean {\n  return SHORT_OPTION_REGEXP.test(arg);\n}\n"],"names":["SHORT_OPTION_REGEXP","isShortOption","arg","test"],"mappings":"AAAA,MAAMA,sBAAsB;AAE5B;;;;;CAKC,GACD,OAAO,SAASC,cAAcC,GAAW;IACvC,OAAOF,oBAAoBG,IAAI,CAACD;AAClC"}

package/dist/internals/isShortOptionsGroup.js

@@ -1,11 +0,0 @@
-export const SHORT_OPTIONS_GROUP_REGEXP = /^-[a-z]{2,}$/iu;
-/**
- * A function that checks if a value is an argument that looks like a short options group, i.e. a dash and a single letter; e.g. `'-x'`.
- *
- * @param value The value to check.
- * @return `true` if `value` is a short option.
- */ export function isShortOptionsGroup(arg) {
-    return SHORT_OPTIONS_GROUP_REGEXP.test(arg);
-}
-
-//# sourceMappingURL=isShortOptionsGroup.js.map

package/dist/internals/isShortOptionsGroup.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internals/isShortOptionsGroup.ts"],"sourcesContent":["export const SHORT_OPTIONS_GROUP_REGEXP = /^-[a-z]{2,}$/iu;\n\n/**\n * A function that checks if a value is an argument that looks like a short options group, i.e. a dash and a single letter; e.g. `'-x'`.\n *\n * @param value The value to check.\n * @return `true` if `value` is a short option.\n */\nexport function isShortOptionsGroup(arg: string): boolean {\n  return SHORT_OPTIONS_GROUP_REGEXP.test(arg);\n}\n"],"names":["SHORT_OPTIONS_GROUP_REGEXP","isShortOptionsGroup","arg","test"],"mappings":"AAAA,OAAO,MAAMA,6BAA6B,iBAAiB;AAE3D;;;;;CAKC,GACD,OAAO,SAASC,oBAAoBC,GAAW;IAC7C,OAAOF,2BAA2BG,IAAI,CAACD;AACzC"}

package/dist/internals/isTrueString.js

@@ -1,10 +0,0 @@
-const TRUE_STRING_REGEXP = /^\s*(?:true|1|yes|on)\s*$/iu;
-/**
- * A function that checks if a string value is a true string. A true string is `'true'`, `'1'`, `'yes'`, or `'on'` (case insensitive).
- *
- * @param value The value to be tested.
- * @return `true` if string is a true string. */ export function isTrueString(value) {
-    return TRUE_STRING_REGEXP.test(value);
-}
-
-//# sourceMappingURL=isTrueString.js.map

package/dist/internals/isTrueString.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/internals/isTrueString.ts"],"sourcesContent":["const TRUE_STRING_REGEXP = /^\\s*(?:true|1|yes|on)\\s*$/iu;\n\n/**\n * A function that checks if a string value is a true string. A true string is `'true'`, `'1'`, `'yes'`, or `'on'` (case insensitive).\n *\n * @param value The value to be tested.\n * @return `true` if string is a true string. */\nexport function isTrueString(value: string) {\n  return TRUE_STRING_REGEXP.test(value);\n}\n"],"names":["TRUE_STRING_REGEXP","isTrueString","value","test"],"mappings":"AAAA,MAAMA,qBAAqB;AAE3B;;;;8CAI8C,GAC9C,OAAO,SAASC,aAAaC,KAAa;IACxC,OAAOF,mBAAmBG,IAAI,CAACD;AACjC"}

package/dist/internals.js

@@ -1,18 +0,0 @@
-export * from './internals/castValue.js';
-export * from './internals/Checker.js';
-export * from './internals/CommandScope.js';
-export * from './internals/commandToArguments.js';
-export * from './internals/createOptionShortNameMap.js';
-export * from './internals/expandArguments.js';
-export * from './internals/isCommand.js';
-export * from './internals/isFalseString.js';
-export * from './internals/isLongOption.js';
-export * from './internals/isOptionLike.js';
-export * from './internals/isShortOption.js';
-export * from './internals/isShortOptionsGroup.js';
-export * from './internals/isTrueString.js';
-export * from './internals/NormalizedCommandConfig.js';
-export * from './internals/NormalizedCommandsConfig.js';
-export * from './internals/OptionScope.js';
-
-//# sourceMappingURL=internals.js.map

package/dist/internals.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/internals.ts"],"sourcesContent":["export * from './internals/castValue.js';\nexport * from './internals/Checker.js';\nexport * from './internals/CommandScope.js';\nexport * from './internals/commandToArguments.js';\nexport * from './internals/createOptionShortNameMap.js';\nexport * from './internals/expandArguments.js';\nexport * from './internals/isCommand.js';\nexport * from './internals/isFalseString.js';\nexport * from './internals/isLongOption.js';\nexport * from './internals/isOptionLike.js';\nexport * from './internals/isShortOption.js';\nexport * from './internals/isShortOptionsGroup.js';\nexport * from './internals/isTrueString.js';\nexport * from './internals/NormalizedCommandConfig.js';\nexport * from './internals/NormalizedCommandsConfig.js';\nexport * from './internals/OptionScope.js';\n"],"names":[],"mappings":"AAAA,cAAc,2BAA2B;AACzC,cAAc,yBAAyB;AACvC,cAAc,8BAA8B;AAC5C,cAAc,oCAAoC;AAClD,cAAc,0CAA0C;AACxD,cAAc,iCAAiC;AAC/C,cAAc,2BAA2B;AACzC,cAAc,+BAA+B;AAC7C,cAAc,8BAA8B;AAC5C,cAAc,8BAA8B;AAC5C,cAAc,+BAA+B;AAC7C,cAAc,qCAAqC;AACnD,cAAc,8BAA8B;AAC5C,cAAc,yCAAyC;AACvD,cAAc,0CAA0C;AACxD,cAAc,6BAA6B"}

package/dist/main.js

@@ -1,20 +0,0 @@
-export * from './Arguments.js';
-export * from './ArgumentsCommand.js';
-export * from './ArgumentsOptions.js';
-export * from './ArgumentsParameters.js';
-export * from './ArgumentsUnknownOptions.js';
-export * from './Argv.js';
-export * from './CommandConfig.js';
-export * from './CommandsConfig.js';
-export * from './LongOptionName.js';
-export * from './OptionConfig.js';
-export * from './OptionsConfig.js';
-export * from './ParameterConfig.js';
-export * from './ParametersConfig.js';
-export * from './parseArguments.js';
-export * from './ParserConfig.js';
-export * from './ParsingError.js';
-export * from './ShortOptionName.js';
-export * from './ValidationError.js';
-
-//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/main.ts"],"sourcesContent":["export * from './Arguments.js';\nexport * from './ArgumentsCommand.js';\nexport * from './ArgumentsOptions.js';\nexport * from './ArgumentsParameters.js';\nexport * from './ArgumentsUnknownOptions.js';\nexport * from './Argv.js';\nexport * from './CommandConfig.js';\nexport * from './CommandsConfig.js';\nexport * from './LongOptionName.js';\nexport * from './OptionConfig.js';\nexport * from './OptionsConfig.js';\nexport * from './ParameterConfig.js';\nexport * from './ParametersConfig.js';\nexport * from './parseArguments.js';\nexport * from './ParserConfig.js';\nexport * from './ParsingError.js';\nexport * from './ShortOptionName.js';\nexport * from './ValidationError.js';\n"],"names":[],"mappings":"AAAA,cAAc,iBAAiB;AAC/B,cAAc,wBAAwB;AACtC,cAAc,wBAAwB;AACtC,cAAc,2BAA2B;AACzC,cAAc,+BAA+B;AAC7C,cAAc,YAAY;AAC1B,cAAc,qBAAqB;AACnC,cAAc,sBAAsB;AACpC,cAAc,sBAAsB;AACpC,cAAc,oBAAoB;AAClC,cAAc,qBAAqB;AACnC,cAAc,uBAAuB;AACrC,cAAc,wBAAwB;AACtC,cAAc,sBAAsB;AACpC,cAAc,oBAAoB;AAClC,cAAc,oBAAoB;AAClC,cAAc,uBAAuB;AACrC,cAAc,uBAAuB"}

package/dist/parseArguments.js

@@ -1,244 +0,0 @@
-import { castValue, Checker, CommandScope, commandToArguments, createOptionShortNameMap, expandArguments, isFalseString, isLongOption, isOptionLike, isShortOption, isTrueString, OptionScope } from './internals.js';
-import { ParsingError } from './ParsingError.js';
-/* eslint-disable no-param-reassign -- we need to add properties to the `parsedOption` object */ function commitOptionScope(optionScope, parsedOptions) {
-    let optionValue = optionScope.getValue();
-    parsedOptions[optionScope.name] = optionValue;
-    if (optionScope.config.validate) {
-        optionScope.config.validate(parsedOptions[optionScope.name]); // type assertion needed to make TypeScript happy
-    }
-}
-/* eslint-enable no-param-reassign */ /**
- * Parses a list of command line arguments into an arguments object. Based on provided parser config, raw arguments can be parsed as commands, options and parameters.
- *
- * @param argv Raw arguments to be parsed.
- * @param parserConfig Parser configuration.
- * @return Parsed arguments.
- *
- */ // TODO: refactor
-// eslint-disable-next-line complexity -- TODO
-export function parseArguments(argv, parserConfig) {
-    // create separate configs for commands, parameters and options
-    let commandsConfig = parserConfig.commands ?? [];
-    let parametersConfig = parserConfig.parameters ?? [];
-    let optionsConfig = parserConfig.options ?? {};
-    // check if parser config is valid
-    let checker = new Checker();
-    checker.checkCommandsConfig(commandsConfig);
-    checker.checkParametersConfig(parametersConfig);
-    checker.checkOptionsConfig(optionsConfig);
-    // normalize some configs
-    let normalizedCommandsConfig = commandsConfig.map((command)=>({
-            command: command.toLowerCase(),
-            args: commandToArguments(command.toLowerCase())
-        }));
-    let commandFirstArguments = normalizedCommandsConfig.map((commandConfig)=>commandConfig.args[0]);
-    let optionShortNameMap = parserConfig.options ? createOptionShortNameMap(parserConfig.options) : {};
-    // variables for keeping track of the parsing
-    let parsedCommand;
-    let parsedParameters = [];
-    let parsedOptions = {};
-    let parsedUnknownOptions = {};
-    let restArgs = [];
-    let optionScope = null;
-    let commandScope = null;
-    //
-    let args = expandArguments(argv);
-    for (let [i, arg] of args.entries()){
-        // extract rest arguments
-        if (arg === '--') {
-            restArgs.push(...args.slice(i + 1));
-            break;
-        }
-        try {
-            if (isOptionLike(arg)) {
-                // first let's handle options
-                if (optionScope) {
-                    commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
-                }
-                // if there is still unhandled `commandScope`, let's handle its args as parameters...
-                if (commandScope) {
-                    let unhandledArgs = commandScope.getArgs();
-                    for (let unhandledArg of unhandledArgs){
-                        if (parserConfig.allowUnknownParameters) {
-                            // let's handle other parameter
-                            parsedParameters.push(unhandledArg);
-                        } else {
-                            checker.addError(new ParsingError('UNKNOWN_PARAMETER', {
-                                messageParameters: [
-                                    unhandledArg
-                                ]
-                            }));
-                        }
-                    }
-                }
-                optionScope = null;
-                commandScope = null;
-                let optionName = arg;
-                let optionValue;
-                // Extract option name and value
-                if (optionName.includes('=')) {
-                    let result = optionName.split('=', 2);
-                    if (result[0] && result[1]) {
-                        [optionName, optionValue] = result;
-                    }
-                }
-                if (isShortOption(optionName)) {
-                    let fullOptionName = optionShortNameMap[optionName.slice(1)];
-                    if (typeof fullOptionName === 'string') {
-                        optionName = fullOptionName;
-                    }
-                } else if (isLongOption(optionName)) {
-                    optionName = optionName.slice(2);
-                }
-                let newOptionScope = new OptionScope(optionName, optionsConfig, parserConfig.allowUnknownOptions);
-                if (typeof parsedOptions[newOptionScope.name] !== 'undefined') {
-                    if (newOptionScope.config.multiple) {
-                        newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];
-                    } else if (newOptionScope.config.type === 'number' && newOptionScope.config.count) {
-                        newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];
-                    }
-                }
-                if (typeof optionValue !== 'undefined') {
-                    newOptionScope.captureArg(optionValue);
-                }
-                if (newOptionScope.isComplete()) {
-                    commitOptionScope(newOptionScope, optionsConfig[newOptionScope.name] ? parsedOptions : parsedUnknownOptions);
-                    optionScope = null;
-                } else {
-                    optionScope = newOptionScope;
-                }
-            } else if (optionScope && !(optionScope.config.type === 'boolean' && !optionScope.config.multiple)) {
-                // let's handle adding more values to previous option, but not if it's signle boolean option
-                optionScope.captureArg(arg);
-                if (optionScope.isComplete()) {
-                    commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
-                    optionScope = null;
-                }
-            } else if (optionScope && optionScope.config.type === 'boolean' && !optionScope.config.multiple && (isFalseString(arg) || isTrueString(arg))) {
-                // we're adding value to a single boolean option only if the value is "false" or "true" string
-                optionScope.captureArg(arg);
-                if (optionScope.isComplete()) {
-                    commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
-                    optionScope = null;
-                }
-            } else if (commandScope) {
-                // let's handle rest of the command
-                commandScope.captureArg(arg);
-                if (commandScope.isComplete()) {
-                    parsedCommand = commandScope.getValue();
-                    commandScope = null;
-                } else if (commandScope.isDone()) {
-                    let unhandledArgs = commandScope.getArgs();
-                    for (let unhandledArg of unhandledArgs){
-                        if (parserConfig.allowUnknownParameters) {
-                            // let's handle other parameter
-                            parsedParameters.push(unhandledArg);
-                        } else {
-                            checker.addError(new ParsingError('UNKNOWN_PARAMETER', {
-                                messageParameters: [
-                                    unhandledArg
-                                ]
-                            }));
-                        }
-                    }
-                    commandScope = null;
-                }
-            } else if (typeof parsedCommand === 'undefined' && commandFirstArguments.includes(arg.toLowerCase())) {
-                // let's handle command
-                let newCommandScope = new CommandScope(arg, normalizedCommandsConfig);
-                if (newCommandScope.isComplete()) {
-                    parsedCommand = newCommandScope.getValue();
-                    commandScope = null;
-                } else {
-                    commandScope = newCommandScope;
-                }
-            } else if (parametersConfig[parsedParameters.length]) {
-                // let's handle configured parameter
-                let parameterConfig = parametersConfig[parsedParameters.length];
-                let parameterValue = castValue(arg, parameterConfig.type);
-                if (parameterConfig.type !== 'boolean' && typeof parameterConfig.choices !== 'undefined' && !parameterConfig.choices.includes(parameterValue) // during runtime `parameterValue` has correct type
-                ) {
-                    throw new ParsingError('INVALID_PARAMETER', {
-                        messageParameters: [
-                            parameterValue,
-                            parameterConfig.label ?? parsedParameters.length,
-                            parameterConfig.choices.map((choice)=>`"${choice}"`).join(', ')
-                        ]
-                    });
-                }
-                parsedParameters.push(parameterValue);
-                if (parameterConfig.validate) {
-                    parameterConfig.validate(parameterValue); // during runtime `parameterValue` has correct type
-                }
-            } else if (parserConfig.allowUnknownParameters) {
-                // let's handle other parameter
-                parsedParameters.push(arg);
-            } else {
-                throw new ParsingError('UNKNOWN_PARAMETER', {
-                    messageParameters: [
-                        arg
-                    ]
-                });
-            }
-        } catch (error) {
-            optionScope = null;
-            commandScope = null;
-            checker.addError(error);
-        }
-    }
-    try {
-        if (optionScope) {
-            commitOptionScope(optionScope, optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions);
-        }
-        // if there is still unhandled `commandScope`, let's handle its args as parameters...
-        if (commandScope) {
-            let unhandledArgs = commandScope.getArgs();
-            for (let unhandledArg of unhandledArgs){
-                if (parserConfig.allowUnknownParameters) {
-                    // let's handle other parameter
-                    parsedParameters.push(unhandledArg);
-                } else {
-                    checker.addError(new ParsingError('UNKNOWN_PARAMETER', {
-                        messageParameters: [
-                            unhandledArg
-                        ]
-                    }));
-                }
-            }
-        }
-        // if there are missing parsed parameters, add undefined
-        for (let [i] of parametersConfig.entries()){
-            if (typeof parsedParameters[i] === 'undefined') {
-                parsedParameters[i] = undefined;
-            }
-        }
-        // handle default option values...
-        for (let [optionName, optionConfig] of Object.entries(optionsConfig)){
-            if (typeof parsedOptions[optionName] === 'undefined' && typeof optionConfig.defaultValue !== 'undefined') {
-                parsedOptions[optionName] = optionConfig.defaultValue;
-            } else if (typeof parsedOptions[optionName] === 'undefined') {
-                parsedOptions[optionName] = undefined;
-            }
-        }
-        // handle default parameters values...
-        for (let [i, parameterConfig] of parametersConfig.entries()){
-            if (typeof parsedParameters[i] === 'undefined' && typeof parameterConfig.defaultValue !== 'undefined') {
-                parsedParameters[i] = parameterConfig.defaultValue;
-            }
-        }
-    } catch (error) {
-        checker.addError(error);
-    }
-    checker.checkParsedParameters(parametersConfig, parsedParameters);
-    checker.checkParsedOptions(optionsConfig, parsedOptions);
-    return {
-        command: normalizedCommandsConfig.length ? parsedCommand : null,
-        parameters: parametersConfig.length || parserConfig.allowUnknownParameters ? parsedParameters : null,
-        options: Object.keys(optionsConfig).length ? parsedOptions : null,
-        unknownOptions: parserConfig.allowUnknownOptions ? parsedUnknownOptions : null,
-        rest: restArgs,
-        errors: checker.errors
-    };
-}
-
-//# sourceMappingURL=parseArguments.js.map

package/dist/parseArguments.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parseArguments.ts"],"sourcesContent":["import {type Arguments} from './Arguments.js';\nimport {type ArgumentsCommand} from './ArgumentsCommand.js';\nimport {type ArgumentsOptions} from './ArgumentsOptions.js';\nimport {type ArgumentsParameters} from './ArgumentsParameters.js';\nimport {type ArgumentsUnknownOptions} from './ArgumentsUnknownOptions.js';\nimport {type Argv} from './Argv.js';\nimport {\n  castValue,\n  Checker,\n  CommandScope,\n  commandToArguments,\n  createOptionShortNameMap,\n  expandArguments,\n  isFalseString,\n  isLongOption,\n  isOptionLike,\n  isShortOption,\n  isTrueString,\n  type NormalizedCommandsConfig,\n  OptionScope,\n} from './internals.js';\nimport {type ParameterConfig} from './ParameterConfig.js';\nimport {type ParserConfig} from './ParserConfig.js';\nimport {ParsingError} from './ParsingError.js';\n\n/* eslint-disable no-param-reassign -- we need to add properties to the `parsedOption` object */\nfunction commitOptionScope(optionScope: OptionScope, parsedOptions: Record<string, unknown>) {\n  let optionValue = optionScope.getValue();\n\n  parsedOptions[optionScope.name] = optionValue;\n\n  if (optionScope.config.validate) {\n    optionScope.config.validate(parsedOptions[optionScope.name] as never); // type assertion needed to make TypeScript happy\n  }\n}\n/* eslint-enable no-param-reassign */\n\n/**\n * Parses a list of command line arguments into an arguments object. Based on provided parser config, raw arguments can be parsed as commands, options and parameters.\n *\n * @param argv Raw arguments to be parsed.\n * @param parserConfig Parser configuration.\n * @return Parsed arguments.\n *\n */\n// TODO: refactor\n// eslint-disable-next-line complexity -- TODO\nexport function parseArguments<const O extends ParserConfig>(\n  argv: Argv,\n  parserConfig: O,\n): Arguments<O> {\n  // create separate configs for commands, parameters and options\n  let commandsConfig = parserConfig.commands ?? [];\n  let parametersConfig = parserConfig.parameters ?? [];\n  let optionsConfig = parserConfig.options ?? {};\n\n  // check if parser config is valid\n  let checker = new Checker();\n\n  checker.checkCommandsConfig(commandsConfig);\n  checker.checkParametersConfig(parametersConfig);\n  checker.checkOptionsConfig(optionsConfig);\n\n  // normalize some configs\n  let normalizedCommandsConfig: NormalizedCommandsConfig = commandsConfig.map((command) => ({\n    command: command.toLowerCase(),\n    args: commandToArguments(command.toLowerCase()),\n  }));\n  let commandFirstArguments = normalizedCommandsConfig.map(\n    (commandConfig) => commandConfig.args[0],\n  );\n  let optionShortNameMap = parserConfig.options\n    ? createOptionShortNameMap(parserConfig.options)\n    : {};\n\n  // variables for keeping track of the parsing\n  let parsedCommand: string | undefined;\n  let parsedParameters: unknown[] = [];\n  let parsedOptions: Record<string, unknown> = {};\n  let parsedUnknownOptions: Record<string, unknown> = {};\n  let restArgs: string[] = [];\n  let optionScope: OptionScope | null = null;\n  let commandScope: CommandScope | null = null;\n\n  //\n  let args = expandArguments(argv);\n\n  for (let [i, arg] of args.entries()) {\n    // extract rest arguments\n    if (arg === '--') {\n      restArgs.push(...args.slice(i + 1));\n\n      break;\n    }\n\n    try {\n      if (isOptionLike(arg)) {\n        // first let's handle options\n\n        if (optionScope) {\n          commitOptionScope(\n            optionScope,\n            optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n        }\n\n        // if there is still unhandled `commandScope`, let's handle its args as parameters...\n        if (commandScope) {\n          let unhandledArgs = commandScope.getArgs();\n\n          for (let unhandledArg of unhandledArgs) {\n            if (parserConfig.allowUnknownParameters) {\n              // let's handle other parameter\n              parsedParameters.push(unhandledArg);\n            } else {\n              checker.addError(\n                new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [unhandledArg]}),\n              );\n            }\n          }\n        }\n\n        optionScope = null;\n        commandScope = null;\n\n        let optionName = arg;\n        let optionValue;\n\n        // Extract option name and value\n        if (optionName.includes('=')) {\n          let result = optionName.split('=', 2);\n\n          if (result[0] && result[1]) {\n            [optionName, optionValue] = result;\n          }\n        }\n\n        if (isShortOption(optionName)) {\n          let fullOptionName = optionShortNameMap[optionName.slice(1)];\n\n          if (typeof fullOptionName === 'string') {\n            optionName = fullOptionName;\n          }\n        } else if (isLongOption(optionName)) {\n          optionName = optionName.slice(2);\n        }\n\n        let newOptionScope = new OptionScope(\n          optionName,\n          optionsConfig,\n          parserConfig.allowUnknownOptions,\n        );\n\n        if (typeof parsedOptions[newOptionScope.name] !== 'undefined') {\n          if (newOptionScope.config.multiple) {\n            newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];\n          } else if (newOptionScope.config.type === 'number' && newOptionScope.config.count) {\n            newOptionScope.previousParsedValue = parsedOptions[newOptionScope.name];\n          }\n        }\n\n        if (typeof optionValue !== 'undefined') {\n          newOptionScope.captureArg(optionValue);\n        }\n\n        if (newOptionScope.isComplete()) {\n          commitOptionScope(\n            newOptionScope,\n            optionsConfig[newOptionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n\n          optionScope = null;\n        } else {\n          optionScope = newOptionScope;\n        }\n      } else if (\n        optionScope &&\n        !(optionScope.config.type === 'boolean' && !optionScope.config.multiple)\n      ) {\n        // let's handle adding more values to previous option, but not if it's signle boolean option\n\n        optionScope.captureArg(arg);\n\n        if (optionScope.isComplete()) {\n          commitOptionScope(\n            optionScope,\n            optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n\n          optionScope = null;\n        }\n      } else if (\n        optionScope &&\n        optionScope.config.type === 'boolean' &&\n        !optionScope.config.multiple &&\n        (isFalseString(arg) || isTrueString(arg))\n      ) {\n        // we're adding value to a single boolean option only if the value is \"false\" or \"true\" string\n        optionScope.captureArg(arg);\n\n        if (optionScope.isComplete()) {\n          commitOptionScope(\n            optionScope,\n            optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n          );\n\n          optionScope = null;\n        }\n      } else if (commandScope) {\n        // let's handle rest of the command\n\n        commandScope.captureArg(arg);\n\n        if (commandScope.isComplete()) {\n          parsedCommand = commandScope.getValue();\n          commandScope = null;\n        } else if (commandScope.isDone()) {\n          let unhandledArgs = commandScope.getArgs();\n\n          for (let unhandledArg of unhandledArgs) {\n            if (parserConfig.allowUnknownParameters) {\n              // let's handle other parameter\n              parsedParameters.push(unhandledArg);\n            } else {\n              checker.addError(\n                new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [unhandledArg]}),\n              );\n            }\n          }\n\n          commandScope = null;\n        }\n      } else if (\n        typeof parsedCommand === 'undefined' &&\n        commandFirstArguments.includes(arg.toLowerCase())\n      ) {\n        // let's handle command\n\n        let newCommandScope = new CommandScope(arg, normalizedCommandsConfig);\n\n        if (newCommandScope.isComplete()) {\n          parsedCommand = newCommandScope.getValue();\n          commandScope = null;\n        } else {\n          commandScope = newCommandScope;\n        }\n      } else if (parametersConfig[parsedParameters.length]) {\n        // let's handle configured parameter\n        let parameterConfig = parametersConfig[parsedParameters.length] as ParameterConfig;\n        let parameterValue = castValue(arg, parameterConfig.type);\n\n        if (\n          parameterConfig.type !== 'boolean' &&\n          typeof parameterConfig.choices !== 'undefined' &&\n          !parameterConfig.choices.includes(parameterValue as never) // during runtime `parameterValue` has correct type\n        ) {\n          throw new ParsingError('INVALID_PARAMETER', {\n            messageParameters: [\n              parameterValue,\n              parameterConfig.label ?? parsedParameters.length,\n              parameterConfig.choices.map((choice) => `\"${choice}\"`).join(', '),\n            ],\n          });\n        }\n\n        parsedParameters.push(parameterValue);\n\n        if (parameterConfig.validate) {\n          parameterConfig.validate(parameterValue as never); // during runtime `parameterValue` has correct type\n        }\n      } else if (parserConfig.allowUnknownParameters) {\n        // let's handle other parameter\n        parsedParameters.push(arg);\n      } else {\n        throw new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [arg]});\n      }\n    } catch (error: unknown) {\n      optionScope = null;\n      commandScope = null;\n\n      checker.addError(error as Error);\n    }\n  }\n\n  try {\n    if (optionScope) {\n      commitOptionScope(\n        optionScope,\n        optionsConfig[optionScope.name] ? parsedOptions : parsedUnknownOptions,\n      );\n    }\n\n    // if there is still unhandled `commandScope`, let's handle its args as parameters...\n    if (commandScope) {\n      let unhandledArgs = commandScope.getArgs();\n\n      for (let unhandledArg of unhandledArgs) {\n        if (parserConfig.allowUnknownParameters) {\n          // let's handle other parameter\n          parsedParameters.push(unhandledArg);\n        } else {\n          checker.addError(\n            new ParsingError('UNKNOWN_PARAMETER', {messageParameters: [unhandledArg]}),\n          );\n        }\n      }\n    }\n\n    // if there are missing parsed parameters, add undefined\n    for (let [i] of parametersConfig.entries()) {\n      if (typeof parsedParameters[i] === 'undefined') {\n        parsedParameters[i] = undefined;\n      }\n    }\n\n    // handle default option values...\n    for (let [optionName, optionConfig] of Object.entries(optionsConfig)) {\n      if (\n        typeof parsedOptions[optionName] === 'undefined' &&\n        typeof optionConfig.defaultValue !== 'undefined'\n      ) {\n        parsedOptions[optionName] = optionConfig.defaultValue;\n      } else if (typeof parsedOptions[optionName] === 'undefined') {\n        parsedOptions[optionName] = undefined;\n      }\n    }\n\n    // handle default parameters values...\n    for (let [i, parameterConfig] of parametersConfig.entries()) {\n      if (\n        typeof parsedParameters[i] === 'undefined' &&\n        typeof parameterConfig.defaultValue !== 'undefined'\n      ) {\n        parsedParameters[i] = parameterConfig.defaultValue;\n      }\n    }\n  } catch (error: unknown) {\n    checker.addError(error as Error);\n  }\n\n  checker.checkParsedParameters(parametersConfig, parsedParameters);\n  checker.checkParsedOptions(optionsConfig, parsedOptions);\n\n  return {\n    command: (normalizedCommandsConfig.length ? parsedCommand : null) as ArgumentsCommand<O>,\n    parameters: (parametersConfig.length || parserConfig.allowUnknownParameters\n      ? parsedParameters\n      : null) as ArgumentsParameters<O>,\n    options: (Object.keys(optionsConfig).length ? parsedOptions : null) as ArgumentsOptions<O>,\n    unknownOptions: (parserConfig.allowUnknownOptions\n      ? parsedUnknownOptions\n      : null) as ArgumentsUnknownOptions<O>,\n    rest: restArgs,\n    errors: checker.errors,\n  };\n}\n"],"names":["castValue","Checker","CommandScope","commandToArguments","createOptionShortNameMap","expandArguments","isFalseString","isLongOption","isOptionLike","isShortOption","isTrueString","OptionScope","ParsingError","commitOptionScope","optionScope","parsedOptions","optionValue","getValue","name","config","validate","parseArguments","argv","parserConfig","commandsConfig","commands","parametersConfig","parameters","optionsConfig","options","checker","checkCommandsConfig","checkParametersConfig","checkOptionsConfig","normalizedCommandsConfig","map","command","toLowerCase","args","commandFirstArguments","commandConfig","optionShortNameMap","parsedCommand","parsedParameters","parsedUnknownOptions","restArgs","commandScope","i","arg","entries","push","slice","unhandledArgs","getArgs","unhandledArg","allowUnknownParameters","addError","messageParameters","optionName","includes","result","split","fullOptionName","newOptionScope","allowUnknownOptions","multiple","previousParsedValue","type","count","captureArg","isComplete","isDone","newCommandScope","length","parameterConfig","parameterValue","choices","label","choice","join","error","undefined","optionConfig","Object","defaultValue","checkParsedParameters","checkParsedOptions","keys","unknownOptions","rest","errors"],"mappings":"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"}

package/src/ArgumentsOptions.ts

@@ -1,89 +0,0 @@
-import {type TupleToUnion} from '@jakubmazanec/ts-utils';
-
-import {
-  type CountOptionConfig,
-  type BooleansOptionConfig,
-  type NumbersOptionConfig,
-  type StringsOptionConfig,
-  type OptionConfig,
-  type BooleanOptionConfig,
-  type NumberOptionConfig,
-  type StringOptionConfig,
-} from './OptionConfig.js';
-import {type OptionsConfig} from './OptionsConfig.js';
-import {type ParserConfig} from './ParserConfig.js';
-
-type BooleanOptionConfigToArgumentsOption<O extends BooleanOptionConfig | BooleansOptionConfig> =
-  O extends BooleanOptionConfig
-    ? O['defaultValue'] extends boolean
-      ? boolean
-      : boolean | undefined
-    : O extends BooleansOptionConfig
-    ? O['defaultValue'] extends readonly boolean[]
-      ? boolean[]
-      : boolean[] | undefined
-    : never;
-
-type NumberOptionConfigToArgumentsOption<
-  O extends CountOptionConfig | NumberOptionConfig | NumbersOptionConfig,
-> = O extends NumbersOptionConfig
-  ? O['choices'] extends readonly number[]
-    ? O['defaultValue'] extends readonly number[]
-      ? Array<TupleToUnion<O['choices']>>
-      : Array<TupleToUnion<O['choices']>> | undefined
-    : O['defaultValue'] extends readonly number[]
-    ? number[]
-    : number[] | undefined
-  : O extends NumberOptionConfig
-  ? O['choices'] extends readonly number[]
-    ? O['defaultValue'] extends number
-      ? TupleToUnion<O['choices']>
-      : TupleToUnion<O['choices']> | undefined
-    : O['defaultValue'] extends number
-    ? number
-    : number | undefined
-  : O extends CountOptionConfig
-  ? O['defaultValue'] extends number
-    ? number
-    : number | undefined
-  : never;
-
-type StringOptionConfigToArgumentsOption<O extends StringOptionConfig | StringsOptionConfig> =
-  O extends StringsOptionConfig
-    ? O['choices'] extends readonly string[]
-      ? O['defaultValue'] extends readonly string[]
-        ? Array<TupleToUnion<O['choices']>>
-        : Array<TupleToUnion<O['choices']>> | undefined
-      : O['defaultValue'] extends readonly string[]
-      ? string[]
-      : string[] | undefined
-    : O extends StringOptionConfig
-    ? O['choices'] extends readonly string[]
-      ? O['defaultValue'] extends string
-        ? TupleToUnion<O['choices']>
-        : TupleToUnion<O['choices']> | undefined
-      : O['defaultValue'] extends string
-      ? string
-      : string | undefined
-    : never;
-
-type OptionConfigToArgumentOption<O extends OptionConfig> = O extends
-  | BooleanOptionConfig
-  | BooleansOptionConfig
-  ? BooleanOptionConfigToArgumentsOption<O>
-  : O extends CountOptionConfig | NumberOptionConfig | NumbersOptionConfig
-  ? NumberOptionConfigToArgumentsOption<O>
-  : O extends StringOptionConfig | StringsOptionConfig
-  ? StringOptionConfigToArgumentsOption<O>
-  : never;
-
-type OptionsConfigToArgumentsOptions<O extends OptionsConfig> = {
-  [K in keyof O]: OptionConfigToArgumentOption<O[K]>;
-};
-
-/** Parsed options. */
-export type ArgumentsOptions<O extends ParserConfig> = Omit<O, 'options'> extends O
-  ? null
-  : O['options'] extends undefined
-  ? null
-  : OptionsConfigToArgumentsOptions<NonNullable<O['options']>>;

package/src/ArgumentsParameters.ts

@@ -1,158 +0,0 @@
-import {type TupleToUnion} from '@jakubmazanec/ts-utils';
-
-import {
-  type ParameterConfig,
-  type BooleanParameterConfig,
-  type NumberParameterConfig,
-  type StringParameterConfig,
-} from './ParameterConfig.js';
-import {type ParametersConfig} from './ParametersConfig.js';
-import {type ParserConfig} from './ParserConfig.js';
-
-type NumberParameterConfigToArgumentsParameter<O extends NumberParameterConfig> =
-  O['choices'] extends readonly number[]
-    ? O['defaultValue'] extends number
-      ? TupleToUnion<O['choices']>
-      : TupleToUnion<O['choices']> | undefined
-    : O['defaultValue'] extends number
-    ? number
-    : number | undefined;
-
-type StringParameterConfigToArgumentsParameter<O extends StringParameterConfig> =
-  O['choices'] extends readonly string[]
-    ? O['defaultValue'] extends string
-      ? TupleToUnion<O['choices']>
-      : TupleToUnion<O['choices']> | undefined
-    : O['defaultValue'] extends string
-    ? string
-    : string | undefined;
-
-type BooleanParameterConfigToArgumentsParameter<O extends BooleanParameterConfig> =
-  O['defaultValue'] extends boolean ? boolean : boolean | undefined;
-
-type ParameterConfigToArgumentsParameter<O extends ParameterConfig> =
-  O extends NumberParameterConfig
-    ? NumberParameterConfigToArgumentsParameter<O>
-    : O extends StringParameterConfig
-    ? StringParameterConfigToArgumentsParameter<O>
-    : O extends BooleanParameterConfig
-    ? BooleanParameterConfigToArgumentsParameter<O>
-    : never;
-
-type ParametersConfigToArgumentsParameters<O extends ParametersConfig> = O extends readonly [
-  ParameterConfig,
-  ParameterConfig,
-  ParameterConfig,
-  ParameterConfig,
-  ParameterConfig,
-  ParameterConfig,
-]
-  ? readonly [
-      ParameterConfigToArgumentsParameter<O[0]>,
-      ParameterConfigToArgumentsParameter<O[1]>,
-      ParameterConfigToArgumentsParameter<O[2]>,
-      ParameterConfigToArgumentsParameter<O[3]>,
-      ParameterConfigToArgumentsParameter<O[4]>,
-      ParameterConfigToArgumentsParameter<O[5]>,
-    ]
-  : O extends readonly [
-      ParameterConfig,
-      ParameterConfig,
-      ParameterConfig,
-      ParameterConfig,
-      ParameterConfig,
-    ]
-  ? readonly [
-      ParameterConfigToArgumentsParameter<O[0]>,
-      ParameterConfigToArgumentsParameter<O[1]>,
-      ParameterConfigToArgumentsParameter<O[2]>,
-      ParameterConfigToArgumentsParameter<O[3]>,
-      ParameterConfigToArgumentsParameter<O[4]>,
-    ]
-  : O extends readonly [ParameterConfig, ParameterConfig, ParameterConfig, ParameterConfig]
-  ? readonly [
-      ParameterConfigToArgumentsParameter<O[0]>,
-      ParameterConfigToArgumentsParameter<O[1]>,
-      ParameterConfigToArgumentsParameter<O[2]>,
-      ParameterConfigToArgumentsParameter<O[3]>,
-    ]
-  : O extends readonly [ParameterConfig, ParameterConfig, ParameterConfig]
-  ? readonly [
-      ParameterConfigToArgumentsParameter<O[0]>,
-      ParameterConfigToArgumentsParameter<O[1]>,
-      ParameterConfigToArgumentsParameter<O[2]>,
-    ]
-  : O extends readonly [ParameterConfig, ParameterConfig]
-  ? readonly [ParameterConfigToArgumentsParameter<O[0]>, ParameterConfigToArgumentsParameter<O[1]>]
-  : O extends readonly [ParameterConfig]
-  ? readonly [ParameterConfigToArgumentsParameter<O[0]>]
-  : never;
-
-type ParametersConfigToVariadicArgumentsParameters<O extends ParametersConfig> =
-  O extends readonly [
-    ParameterConfig,
-    ParameterConfig,
-    ParameterConfig,
-    ParameterConfig,
-    ParameterConfig,
-    ParameterConfig,
-  ]
-    ? readonly [
-        ParameterConfigToArgumentsParameter<O[0]>,
-        ParameterConfigToArgumentsParameter<O[1]>,
-        ParameterConfigToArgumentsParameter<O[2]>,
-        ParameterConfigToArgumentsParameter<O[3]>,
-        ParameterConfigToArgumentsParameter<O[4]>,
-        ParameterConfigToArgumentsParameter<O[5]>,
-        ...(readonly string[]),
-      ]
-    : O extends readonly [
-        ParameterConfig,
-        ParameterConfig,
-        ParameterConfig,
-        ParameterConfig,
-        ParameterConfig,
-      ]
-    ? readonly [
-        ParameterConfigToArgumentsParameter<O[0]>,
-        ParameterConfigToArgumentsParameter<O[1]>,
-        ParameterConfigToArgumentsParameter<O[2]>,
-        ParameterConfigToArgumentsParameter<O[3]>,
-        ParameterConfigToArgumentsParameter<O[4]>,
-        ...(readonly string[]),
-      ]
-    : O extends readonly [ParameterConfig, ParameterConfig, ParameterConfig, ParameterConfig]
-    ? readonly [
-        ParameterConfigToArgumentsParameter<O[0]>,
-        ParameterConfigToArgumentsParameter<O[1]>,
-        ParameterConfigToArgumentsParameter<O[2]>,
-        ParameterConfigToArgumentsParameter<O[3]>,
-        ...(readonly string[]),
-      ]
-    : O extends readonly [ParameterConfig, ParameterConfig, ParameterConfig]
-    ? readonly [
-        ParameterConfigToArgumentsParameter<O[0]>,
-        ParameterConfigToArgumentsParameter<O[1]>,
-        ParameterConfigToArgumentsParameter<O[2]>,
-        ...(readonly string[]),
-      ]
-    : O extends readonly [ParameterConfig, ParameterConfig]
-    ? readonly [
-        ParameterConfigToArgumentsParameter<O[0]>,
-        ParameterConfigToArgumentsParameter<O[1]>,
-        ...(readonly string[]),
-      ]
-    : O extends readonly [ParameterConfig]
-    ? readonly [ParameterConfigToArgumentsParameter<O[0]>, ...(readonly string[])]
-    : readonly [...(readonly string[])];
-
-/** Parsed parameters. */
-export type ArgumentsParameters<O extends ParserConfig> = Omit<O, 'parameters'> extends O
-  ? O['allowUnknownParameters'] extends true
-    ? [...string[]]
-    : null
-  : O['parameters'] extends undefined
-  ? null
-  : O['allowUnknownParameters'] extends true
-  ? ParametersConfigToVariadicArgumentsParameters<NonNullable<O['parameters']>>
-  : ParametersConfigToArgumentsParameters<NonNullable<O['parameters']>>;

package/src/ArgumentsUnknownOptions.ts

@@ -1,6 +0,0 @@
-import {type ParserConfig} from './ParserConfig.js';
-
-/** Unknown options. Unknown options are always parsed as strings. */
-export type ArgumentsUnknownOptions<O extends ParserConfig> = O['allowUnknownOptions'] extends true
-  ? Record<string, unknown>
-  : null;