{"version":3,"file":"BaseClasses.js","sourceRoot":"","sources":["../../src/parameters/BaseClasses.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport type { SCOPING_PARAMETER_GROUP } from '../Constants';\nimport type {\n  IBaseCommandLineDefinition,\n  IBaseCommandLineDefinitionWithArgument\n} from './CommandLineDefinition';\nimport type { CommandLineChoiceListParameter } from './CommandLineChoiceListParameter';\nimport type { CommandLineChoiceParameter } from './CommandLineChoiceParameter';\nimport type { CommandLineFlagParameter } from './CommandLineFlagParameter';\nimport type { CommandLineIntegerListParameter } from './CommandLineIntegerListParameter';\nimport type { CommandLineIntegerParameter } from './CommandLineIntegerParameter';\nimport type { CommandLineStringListParameter } from './CommandLineStringListParameter';\nimport type { CommandLineStringParameter } from './CommandLineStringParameter';\n\n/**\n * Identifies the kind of a CommandLineParameter.\n * @public\n */\nexport enum CommandLineParameterKind {\n  /** Indicates a CommandLineChoiceParameter */\n  Choice,\n  /** Indicates a CommandLineFlagParameter */\n  Flag,\n  /** Indicates a CommandLineIntegerParameter */\n  Integer,\n  /** Indicates a CommandLineStringParameter */\n  String,\n  /** Indicates a CommandLineStringListParameter */\n  StringList,\n  /** Indicates a CommandLineChoiceListParameter */\n  ChoiceList,\n  /** Indicates a CommandLineIntegerListParameter */\n  IntegerList\n}\n\n/**\n * Matches kebab-case formatted strings prefixed with double dashes.\n * Example: \"--do-something\"\n */\nconst LONG_NAME_REGEXP: RegExp = /^-(-[a-z0-9]+)+$/;\n\n/**\n * Matches a single upper-case or lower-case letter prefixed with a dash.\n * Example: \"-d\"\n */\nconst SHORT_NAME_REGEXP: RegExp = /^-[a-zA-Z]$/;\n\n/**\n * Matches kebab-case formatted strings\n * Example: \"my-scope\"\n */\nconst SCOPE_REGEXP: RegExp = /^[a-z0-9]+(-[a-z0-9]+)*$/;\n\n/**\n * \"Environment variable names used by the utilities in the Shell and Utilities volume of\n * IEEE Std 1003.1-2001 consist solely of uppercase letters, digits, and the '_' (underscore)\n * from the characters defined in Portable Character Set and do not begin with a digit.\"\n * Example: \"THE_SETTING\"\n */\nconst ENVIRONMENT_VARIABLE_NAME_REGEXP: RegExp = /^[A-Z_][A-Z0-9_]*$/;\n\nexport type CommandLineParameter =\n  | CommandLineChoiceListParameter\n  | CommandLineChoiceParameter\n  | CommandLineFlagParameter\n  | CommandLineIntegerListParameter\n  | CommandLineIntegerParameter\n  | CommandLineStringListParameter\n  | CommandLineStringParameter;\n\n/**\n * The base class for the various command-line parameter types.\n * @public\n */\nexport abstract class CommandLineParameterBase {\n  private _shortNameValue: string | undefined;\n\n  /**\n   * A unique internal key used to retrieve the value from the parser's dictionary.\n   * @internal\n   */\n  public _parserKey: string | undefined;\n\n  /**\n   * @internal\n   */\n  public _preParse?: () => void;\n\n  /**\n   * @internal\n   */\n  public _postParse?: () => void;\n\n  /**\n   * @internal\n   */\n  public _validateValue?: () => void;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.parameterLongName} */\n  public readonly longName: string;\n\n  /**\n   * If a parameterScope is provided, returns the scope-prefixed long name of the flag,\n   * including double dashes, eg. \"--scope:do-something\". Otherwise undefined.\n   */\n  public readonly scopedLongName: string | undefined;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.parameterGroup} */\n  public readonly parameterGroup: string | typeof SCOPING_PARAMETER_GROUP | undefined;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.parameterScope} */\n  public readonly parameterScope: string | undefined;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.description} */\n  public readonly description: string;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.required} */\n  public readonly required: boolean;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.environmentVariable} */\n  public readonly environmentVariable: string | undefined;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.allowNonStandardEnvironmentVariableNames} */\n  public readonly allowNonStandardEnvironmentVariableNames: boolean | undefined;\n\n  /** {@inheritDoc IBaseCommandLineDefinition.undocumentedSynonyms } */\n  public readonly undocumentedSynonyms: string[] | undefined;\n\n  /** @internal */\n  public constructor(definition: IBaseCommandLineDefinition) {\n    this.longName = definition.parameterLongName;\n    this._shortNameValue = definition.parameterShortName;\n    this.parameterGroup = definition.parameterGroup;\n    this.parameterScope = definition.parameterScope;\n    this.description = definition.description;\n    this.required = !!definition.required;\n    this.environmentVariable = definition.environmentVariable;\n    this.undocumentedSynonyms = definition.undocumentedSynonyms;\n    this.allowNonStandardEnvironmentVariableNames = definition.allowNonStandardEnvironmentVariableNames;\n\n    if (!LONG_NAME_REGEXP.test(this.longName)) {\n      throw new Error(\n        `Invalid name: \"${this.longName}\". The parameter long name must be` +\n          ` lower-case and use dash delimiters (e.g. \"--do-a-thing\")`\n      );\n    }\n\n    if (this.shortName) {\n      if (!SHORT_NAME_REGEXP.test(this.shortName)) {\n        throw new Error(\n          `Invalid name: \"${this.shortName}\". The parameter short name must be` +\n            ` a dash followed by a single upper-case or lower-case letter (e.g. \"-a\")`\n        );\n      }\n    }\n\n    if (this.parameterScope) {\n      if (!SCOPE_REGEXP.test(this.parameterScope)) {\n        throw new Error(\n          `Invalid scope: \"${this.parameterScope}\". The parameter scope name must be` +\n            ` lower-case and use dash delimiters (e.g. \"my-scope\")`\n        );\n      }\n      // Parameter long name is guaranteed to start with '--' since this is validated above\n      const unprefixedLongName: string = this.longName.slice(2);\n      this.scopedLongName = `--${this.parameterScope}:${unprefixedLongName}`;\n    }\n\n    if (this.environmentVariable) {\n      if (\n        !this.allowNonStandardEnvironmentVariableNames &&\n        !ENVIRONMENT_VARIABLE_NAME_REGEXP.test(this.environmentVariable)\n      ) {\n        throw new Error(\n          `Invalid environment variable name: \"${this.environmentVariable}\". The name must` +\n            ` consist only of upper-case letters, numbers, and underscores. It may not start with a number.`\n        );\n      }\n    }\n\n    if (this.undocumentedSynonyms && this.undocumentedSynonyms.length > 0) {\n      for (const undocumentedSynonym of this.undocumentedSynonyms) {\n        if (this.longName === undocumentedSynonym) {\n          throw new Error(\n            `Invalid name: \"${undocumentedSynonym}\". Undocumented synonyms must not be the same` +\n              ` as the the long name.`\n          );\n        } else if (!LONG_NAME_REGEXP.test(undocumentedSynonym)) {\n          throw new Error(\n            `Invalid name: \"${undocumentedSynonym}\". All undocumented synonyms name must be lower-case and ` +\n              'use dash delimiters (e.g. \"--do-a-thing\")'\n          );\n        }\n      }\n    }\n  }\n\n  /** {@inheritDoc IBaseCommandLineDefinition.parameterShortName} */\n  public get shortName(): string | undefined {\n    return this._shortNameValue;\n  }\n\n  /**\n   * Called internally by CommandLineParameterProvider._processParsedData()\n   * @internal\n   */\n  public abstract _setValue(data: unknown): void;\n\n  /**\n   * Returns additional text used by the help formatter.\n   * @internal\n   */\n  public _getSupplementaryNotes(supplementaryNotes: string[]): void {\n    // virtual\n    if (this.environmentVariable !== undefined) {\n      supplementaryNotes.push(\n        'This parameter may alternatively be specified via the ' +\n          this.environmentVariable +\n          ' environment variable.'\n      );\n    }\n  }\n\n  /**\n   * Indicates the type of parameter.\n   */\n  public abstract get kind(): CommandLineParameterKind;\n\n  /**\n   * Append the parsed values to the provided string array.\n   * @remarks\n   * Sometimes a command line parameter is not used directly, but instead gets passed through to another\n   * tool that will use it.  For example if our parameter comes in as \"--max-count 3\", then we might want to\n   * call `child_process.spawn()` and append [\"--max-count\", \"3\"] to the args array for that tool.\n   * appendToArgList() appends zero or more strings to the provided array, based on the input command-line\n   * that we parsed.\n   *\n   * If the parameter was omitted from our command-line and has no default value, then\n   * nothing will be appended.  If the short name was used, the long name will be appended instead.\n   * @param argList - the parsed strings will be appended to this string array\n   */\n  public abstract appendToArgList(argList: string[]): void;\n\n  /**\n   * Internal usage only.  Used to report unexpected output from the argparse library.\n   */\n  protected reportInvalidData(data: unknown): never {\n    throw new Error(`Unexpected data object for parameter \"${this.longName}\": ` + JSON.stringify(data));\n  }\n\n  protected validateDefaultValue(hasDefaultValue: boolean): void {\n    if (this.required && hasDefaultValue) {\n      // If a parameter is \"required\", then the user understands that they always need to\n      // specify a value for this parameter (either via the command line or via an environment variable).\n      // It would be confusing to allow a default value that sometimes allows the \"required\" parameter\n      // to be omitted.  If you sometimes don't have a suitable default value, then the better approach\n      // is to throw a custom error explaining why the parameter is required in that case.\n      throw new Error(\n        `A default value cannot be specified for \"${this.longName}\" because it is a \"required\" parameter`\n      );\n    }\n  }\n}\n\n/**\n * The common base class for parameters types that receive an argument.\n *\n * @remarks\n * An argument is an accompanying command-line token, such as \"123\" in the\n * example \"--max-count 123\".\n * @public\n */\nexport abstract class CommandLineParameterWithArgument extends CommandLineParameterBase {\n  // Matches the first character that *isn't* part of a valid upper-case argument name such as \"URL_2\"\n  private static _invalidArgumentNameRegExp: RegExp = /[^A-Z_0-9]/;\n\n  /** {@inheritDoc IBaseCommandLineDefinitionWithArgument.argumentName} */\n  public readonly argumentName: string;\n\n  /** {@inheritDoc IBaseCommandLineDefinitionWithArgument.completions} */\n  public readonly completions: (() => Promise<ReadonlyArray<string> | ReadonlySet<string>>) | undefined;\n\n  /** @internal */\n  public constructor(definition: IBaseCommandLineDefinitionWithArgument) {\n    super(definition);\n\n    if (definition.argumentName === '') {\n      throw new Error(\n        'The argument name cannot be an empty string. (For the default name, specify undefined.)'\n      );\n    }\n    if (definition.argumentName.toUpperCase() !== definition.argumentName) {\n      throw new Error(\n        `Invalid name: \"${definition.argumentName}\". The argument name must be all upper case.`\n      );\n    }\n    const match: RegExpMatchArray | null = definition.argumentName.match(\n      CommandLineParameterWithArgument._invalidArgumentNameRegExp\n    );\n    if (match) {\n      throw new Error(\n        `The argument name \"${definition.argumentName}\" contains an invalid character \"${match[0]}\".` +\n          ` Only upper-case letters, numbers, and underscores are allowed.`\n      );\n    }\n    this.argumentName = definition.argumentName;\n    this.completions = definition.completions;\n  }\n}\n"]}