@jakubmazanec/args 1.0.0-de51f16

package/src/parseArguments.ts

@@ -0,0 +1,358 @@
+import {
+  castValue,
+  Checker,
+  CommandScope,
+  commandToArguments,
+  createOptionShortNameMap,
+  expandArguments,
+  isFalseString,
+  isLongOption,
+  isOptionLike,
+  isShortOption,
+  isTrueString,
+  OptionScope,
+} from './internals.js';
+import {ParsingError} from './ParsingError.js';
+import {
+  type Arguments,
+  type ArgumentsCommand,
+  type ArgumentsOptions,
+  type ArgumentsParameters,
+  type ArgumentsUnknownOptions,
+  type Argv,
+  type NormalizedCommandsConfig,
+  type ParameterConfig,
+  type ParserConfig,
+} from './types.js';
+
+/* eslint-disable no-param-reassign -- we need to add properties to the `parsedOption` object */
+function commitOptionScope(optionScope: OptionScope, parsedOptions: Record<string, unknown>) {
+  let optionValue = optionScope.getValue();
+
+  parsedOptions[optionScope.name] = optionValue;
+
+  if (optionScope.config.validate) {
+    optionScope.config.validate(parsedOptions[optionScope.name] as never); // type assertion needed to make TypeScript happy
+  }
+}
+/* eslint-enable no-param-reassign */
+
+/**
+ * Parse 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<const O extends ParserConfig>(
+  argv: Argv,
+  parserConfig: O,
+): Arguments<O> {
+  // 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: 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: string | undefined;
+  let parsedParameters: unknown[] = [];
+  let parsedOptions: Record<string, unknown> = {};
+  let parsedUnknownOptions: Record<string, unknown> = {};
+  let restArgs: string[] = [];
+  let optionScope: OptionScope | null = null;
+  let commandScope: CommandScope | null = 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] as ParameterConfig;
+        let parameterValue = castValue(arg, parameterConfig.type);
+
+        if (
+          parameterConfig.type !== 'boolean' &&
+          typeof parameterConfig.choices !== 'undefined' &&
+          !parameterConfig.choices.includes(parameterValue as never) // 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 as never); // 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: unknown) {
+      optionScope = null;
+      commandScope = null;
+
+      checker.addError(error as 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: unknown) {
+    checker.addError(error as Error);
+  }
+
+  checker.checkParsedParameters(parametersConfig, parsedParameters);
+  checker.checkParsedOptions(optionsConfig, parsedOptions);
+
+  return {
+    command: (normalizedCommandsConfig.length ? parsedCommand : null) as ArgumentsCommand<O>,
+    parameters: (parametersConfig.length || parserConfig.allowUnknownParameters
+      ? parsedParameters
+      : null) as ArgumentsParameters<O>,
+    options: (Object.keys(optionsConfig).length ? parsedOptions : null) as ArgumentsOptions<O>,
+    unknownOptions: (parserConfig.allowUnknownOptions
+      ? parsedUnknownOptions
+      : null) as ArgumentsUnknownOptions<O>,
+    rest: restArgs,
+    errors: checker.errors,
+  };
+}

package/src/types/Arguments.ts

@@ -0,0 +1,28 @@
+import {type ArgumentsCommand} from './ArgumentsCommand.js';
+import {type ArgumentsOptions} from './ArgumentsOptions.js';
+import {type ArgumentsParameters} from './ArgumentsParameters.js';
+import {type ArgumentsUnknownOptions} from './ArgumentsUnknownOptions.js';
+import {type ParserConfig} from './ParserConfig.js';
+
+/**
+ * Parsed arguments.
+ */
+export type Arguments<T extends ParserConfig> = {
+  /** Parsed command. */
+  readonly command: ArgumentsCommand<T>;
+
+  /** Parsed parameters. */
+  readonly parameters: ArgumentsParameters<T>;
+
+  /** Parsed options. */
+  readonly options: ArgumentsOptions<T>;
+
+  /** Unconfigured options. */
+  readonly unknownOptions: ArgumentsUnknownOptions<T>;
+
+  /** Arguments that appear after "--". */
+  readonly rest: string[];
+
+  /** Parsing and validation rrors */
+  readonly errors: Error[];
+};

package/src/types/ArgumentsCommand.ts

@@ -0,0 +1,8 @@
+import {type ParserConfig} from './ParserConfig.js';
+
+/** Parsed command. */
+export type ArgumentsCommand<O extends ParserConfig> = Omit<O, 'commands'> extends O
+  ? null
+  : O['commands'] extends undefined
+  ? null
+  : Lowercase<NonNullable<O['commands']>[number]> | undefined;

package/src/types/ArgumentsOptions.ts

@@ -0,0 +1,89 @@
+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/types/ArgumentsParameters.ts

@@ -0,0 +1,158 @@
+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/types/ArgumentsUnknownOptions.ts

@@ -0,0 +1,6 @@
+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;

package/src/types/Argv.ts

@@ -0,0 +1,2 @@
+/** Unparsed arguments. */
+export type Argv = string[];

package/src/types/CommandConfig.ts

@@ -0,0 +1,2 @@
+/** A type representing parser's command configuration. */
+export type CommandConfig = string;

package/src/types/CommandsConfig.ts

@@ -0,0 +1,4 @@
+import {type CommandConfig} from './CommandConfig.js';
+
+/** A type representing parser's commands configuration. */
+export type CommandsConfig = readonly CommandConfig[];

package/src/types/LongOptionName.ts

@@ -0,0 +1,2 @@
+/** Long option name. */
+export type LongOptionName = string;

package/src/types/NormalizedCommandConfig.ts

@@ -0,0 +1,5 @@
+/** A type representing parser's normalized command configuration. */
+export type NormalizedCommandConfig = {
+  command: string;
+  args: string[];
+};

package/src/types/NormalizedCommandsConfig.ts

@@ -0,0 +1,4 @@
+import {type NormalizedCommandConfig} from './NormalizedCommandConfig.js';
+
+/** A type representing parser's normalized commands configuration. */
+export type NormalizedCommandsConfig = NormalizedCommandConfig[];