Add global args resolution

Author: schaable

v-next/core/src/internal/global-options.ts

@@ -1,4 +1,7 @@
-import type { ParameterTypeToValueType } from "../types/common.js";
+import type {
+  ParameterTypeToValueType,
+  ParameterValue,
+} from "../types/common.js";
 import type {
   GlobalOptions,
   GlobalOption,
@@ -7,21 +10,24 @@ import type {
 import type { HardhatPlugin } from "../types/plugins.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import { camelToSnakeCase } from "@nomicfoundation/hardhat-utils/string";
 
 import { ParameterType } from "../types/common.js";
 
 import {
   RESERVED_PARAMETER_NAMES,
   isParameterValueValid,
   isValidParamNameCasing,
+  parseParameterValue,
 } from "./parameters.js";
 
 /**
- * Builds a map of the global options, validating them.
+ * Builds a map of the global option definitions by going through all the
+ * plugins and validating the global options they define.
  *
  * Note: this function can be used before initializing the HRE, so the plugins
  * shouldn't be consider validated. Hence, we should validate the global
- * parameters.
+ * options.
  */
 export function buildGlobalOptionsMap(
   resolvedPlugins: HardhatPlugin[],
@@ -60,6 +66,10 @@ export function buildGlobalOptionsMap(
   return globalOptionsMap;
 }
 
+/**
+ * Builds a global option definition, validating the name, type, and default
+ * value.
+ */
 export function buildGlobalOptionDefinition<T extends ParameterType>({
   name,
   description,
@@ -104,13 +114,50 @@ export function buildGlobalOptionDefinition<T extends ParameterType>({
   };
 }
 
+/**
+ * Resolves global options by merging user-provided options with environment
+ * variables, adhering to predefined global option definitions. This function
+ * ensures that only options specified in the globalOptionsMap are considered.
+ * Each option is validated against its definition in the map, with
+ * user-provided options taking precedence over environment variables. If an
+ * option is not provided by the user or set as an environment variable, its
+ * default value (as specified in the globalOptionsMap) is used.
+ *
+ * @param userProvidedGlobalOptions The options explicitly provided by the
+ * user. These take precedence over equivalent environment variables.
+ * @param globalOptionsMap A map defining valid global options, their default
+ * values, and expected types. This map is used to validate and parse the options.
+ * @returns {GlobalOptions} An object containing the resolved global options,
+ * with each option adhering to its definition in the globalOptionsMap.
+ * @throws {HardhatError} with descriptor
+ * {@link HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE} if a user-provided
+ * option has an invalid value for its type.
+ */
 export function resolveGlobalOptions(
   userProvidedGlobalOptions: Partial<GlobalOptions>,
-  _globalOptionsMap: GlobalOptionsMap,
+  globalOptionsMap: GlobalOptionsMap,
 ): GlobalOptions {
-  // TODO: Validate the userProvidedGlobalOptions and get the remaining ones
-  // from env variables
+  const globalOptions: GlobalOptions = {};
+  // iterate over the definitions to parse and validate the arguments
+  for (const [name, { option }] of globalOptionsMap) {
+    let value =
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      -- GlobalOptions is empty for user extension, so we need to cast it to
+      assign the value. */
+      (userProvidedGlobalOptions as Record<string, string | undefined>)[name];
+    if (value === undefined) {
+      value = process.env[`HARDHAT_${camelToSnakeCase(name).toUpperCase()}`];
+    }
+
+    let parsedValue: ParameterValue;
+    if (value !== undefined) {
+      parsedValue = parseParameterValue(value, option.parameterType, name);
+    } else {
+      parsedValue = option.defaultValue;
+    }
+
+    globalOptions[name] = parsedValue;
+  }
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO
-  return userProvidedGlobalOptions as GlobalOptions;
+  return globalOptions;
 }