Rename globalOptionsMap to globalOptionDefinitions

v-next/core/src/index.ts

@@ -28,4 +28,4 @@ export async function createHardhatRuntimeEnvironment(
 }
 
 export { resolvePluginList } from "./internal/plugins/resolve-plugin-list.js";
-export { buildGlobalOptionsMap } from "./internal/global-options.js";
+export { buildGlobalOptionDefinitions } from "./internal/global-options.js";

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

@@ -5,7 +5,7 @@ import type {
 import type {
   GlobalOptions,
   GlobalOption,
-  GlobalOptionsMap,
+  GlobalOptionDefinitions,
 } from "../types/global-options.js";
 import type { HardhatPlugin } from "../types/plugins.js";
 
@@ -29,18 +29,18 @@ import {
  * shouldn't be consider validated. Hence, we should validate the global
  * options.
  */
-export function buildGlobalOptionsMap(
+export function buildGlobalOptionDefinitions(
   resolvedPlugins: HardhatPlugin[],
-): GlobalOptionsMap {
-  const globalOptionsMap: GlobalOptionsMap = new Map();
+): GlobalOptionDefinitions {
+  const globalOptionDefinitions: GlobalOptionDefinitions = new Map();
 
   for (const plugin of resolvedPlugins) {
     if (plugin.globalOptions === undefined) {
       continue;
     }
 
     for (const option of plugin.globalOptions) {
-      const existingByName = globalOptionsMap.get(option.name);
+      const existingByName = globalOptionDefinitions.get(option.name);
       if (existingByName !== undefined) {
         throw new HardhatError(
           HardhatError.ERRORS.GENERAL.GLOBAL_OPTION_ALREADY_DEFINED,
@@ -59,11 +59,11 @@ export function buildGlobalOptionsMap(
         option: validatedGlobalOption,
       };
 
-      globalOptionsMap.set(validatedGlobalOption.name, mapEntry);
+      globalOptionDefinitions.set(validatedGlobalOption.name, mapEntry);
     }
   }
 
-  return globalOptionsMap;
+  return globalOptionDefinitions;
 }
 
 /**
@@ -117,29 +117,29 @@ 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
+ * ensures that only options specified in the globalOptionDefinitions 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.
+ * default value (as specified in the globalOptionDefinitions) 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
+ * @param globalOptionDefinitions 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.
+ * with each option adhering to its definition in the globalOptionDefinitions.
  * @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,
+  globalOptionDefinitions: GlobalOptionDefinitions,
 ): GlobalOptions {
   const globalOptions: GlobalOptions = {};
   // iterate over the definitions to parse and validate the arguments
-  for (const [name, { option }] of globalOptionsMap) {
+  for (const [name, { option }] of globalOptionDefinitions) {
     let value =
       /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       -- GlobalOptions is empty for user extension, so we need to cast it to

v-next/core/src/internal/hre.ts

@@ -2,7 +2,7 @@ import type { UnsafeHardhatRuntimeEnvironmentOptions } from "../types/cli.js";
 import type { HardhatUserConfig, HardhatConfig } from "../types/config.js";
 import type {
   GlobalOptions,
-  GlobalOptionsMap,
+  GlobalOptionDefinitions,
 } from "../types/global-options.js";
 import type {
   HardhatUserConfigValidationError,
@@ -18,7 +18,7 @@ import { HardhatError } from "@ignored/hardhat-vnext-errors";
 
 import { ResolvedConfigurationVariableImplementation } from "./configuration-variables.js";
 import {
-  buildGlobalOptionsMap,
+  buildGlobalOptionDefinitions,
   resolveGlobalOptions,
 } from "./global-options.js";
 import { HookManagerImplementation } from "./hook-manager.js";
@@ -87,12 +87,13 @@ export class HardhatRuntimeEnvironmentImplementation
       plugins: resolvedPlugins,
     };
 
-    const globalOptionsMap =
-      unsafeOptions?.globalOptionsMap ?? buildGlobalOptionsMap(resolvedPlugins);
+    const globalOptionDefinitions =
+      unsafeOptions?.globalOptionDefinitions ??
+      buildGlobalOptionDefinitions(resolvedPlugins);
 
     const globalOptions = resolveGlobalOptions(
       userProvidedGlobalOptions,
-      globalOptionsMap,
+      globalOptionDefinitions,
     );
 
     // Set the HookContext in the hook manager so that non-config hooks can
@@ -115,7 +116,7 @@ export class HardhatRuntimeEnvironmentImplementation
       hooks,
       interruptions,
       globalOptions,
-      globalOptionsMap,
+      globalOptionDefinitions,
     );
 
     await hooks.runSequentialHandlers("hre", "created", [hre]);
@@ -131,9 +132,9 @@ export class HardhatRuntimeEnvironmentImplementation
     public readonly hooks: HookManager,
     public readonly interruptions: UserInterruptionManager,
     public readonly globalOptions: GlobalOptions,
-    globalOptionsMap: GlobalOptionsMap,
+    globalOptionDefinitions: GlobalOptionDefinitions,
   ) {
-    this.tasks = new TaskManagerImplementation(this, globalOptionsMap);
+    this.tasks = new TaskManagerImplementation(this, globalOptionDefinitions);
   }
 }
 

v-next/core/src/internal/tasks/task-manager.ts

@@ -1,4 +1,4 @@
-import type { GlobalOptionsMap } from "../../types/global-options.js";
+import type { GlobalOptionDefinitions } from "../../types/global-options.js";
 import type { HardhatRuntimeEnvironment } from "../../types/hre.js";
 import type {
   Task,
@@ -24,7 +24,7 @@ export class TaskManagerImplementation implements TaskManager {
 
   constructor(
     hre: HardhatRuntimeEnvironment,
-    globalOptionsMap: GlobalOptionsMap,
+    globalOptionDefinitions: GlobalOptionDefinitions,
   ) {
     this.#hre = hre;
 
@@ -35,13 +35,17 @@ export class TaskManagerImplementation implements TaskManager {
       }
 
       for (const taskDefinition of plugin.tasks) {
-        this.#reduceTaskDefinition(globalOptionsMap, taskDefinition, plugin.id);
+        this.#reduceTaskDefinition(
+          globalOptionDefinitions,
+          taskDefinition,
+          plugin.id,
+        );
       }
     }
 
     // reduce global user defined tasks
     for (const taskDefinition of this.#hre.config.tasks) {
-      this.#reduceTaskDefinition(globalOptionsMap, taskDefinition);
+      this.#reduceTaskDefinition(globalOptionDefinitions, taskDefinition);
     }
   }
 
@@ -132,7 +136,7 @@ export class TaskManagerImplementation implements TaskManager {
   }
 
   #reduceTaskDefinition(
-    globalOptionsMap: GlobalOptionsMap,
+    globalOptionDefinitions: GlobalOptionDefinitions,
     taskDefinition: TaskDefinition,
     pluginId?: string,
   ) {
@@ -150,7 +154,7 @@ export class TaskManagerImplementation implements TaskManager {
       }
       case TaskDefinitionType.NEW_TASK: {
         this.#validateClashesWithGlobalOptions(
-          globalOptionsMap,
+          globalOptionDefinitions,
           taskDefinition,
           pluginId,
         );
@@ -170,7 +174,7 @@ export class TaskManagerImplementation implements TaskManager {
       }
       case TaskDefinitionType.TASK_OVERRIDE: {
         this.#validateClashesWithGlobalOptions(
-          globalOptionsMap,
+          globalOptionDefinitions,
           taskDefinition,
           pluginId,
         );
@@ -182,7 +186,7 @@ export class TaskManagerImplementation implements TaskManager {
   }
 
   #validateClashesWithGlobalOptions(
-    globalOptionsMap: GlobalOptionsMap,
+    globalOptionDefinitions: GlobalOptionDefinitions,
     taskDefinition: NewTaskDefinition | TaskOverrideDefinition,
     pluginId?: string,
   ) {
@@ -193,7 +197,7 @@ export class TaskManagerImplementation implements TaskManager {
         : [];
 
     [...optionNames, ...positionalParamNames].forEach((paramName) => {
-      const globalOptionEntry = globalOptionsMap.get(paramName);
+      const globalOptionEntry = globalOptionDefinitions.get(paramName);
       if (globalOptionEntry !== undefined) {
         throw new HardhatError(
           HardhatError.ERRORS.TASK_DEFINITIONS.TASK_OPTION_ALREADY_DEFINED,

v-next/core/src/types/cli.ts

@@ -1,4 +1,4 @@
-import type { GlobalOptionsMap } from "./global-options.js";
+import type { GlobalOptionDefinitions } from "./global-options.js";
 import type { HardhatPlugin } from "./plugins.js";
 
 /**
@@ -7,5 +7,5 @@ import type { HardhatPlugin } from "./plugins.js";
  */
 export interface UnsafeHardhatRuntimeEnvironmentOptions {
   resolvedPlugins?: HardhatPlugin[];
-  globalOptionsMap?: GlobalOptionsMap;
+  globalOptionDefinitions?: GlobalOptionDefinitions;
 }

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

@@ -29,14 +29,14 @@ export interface GlobalOptions {}
 
 /**
  * An entry in the global options map.
- * @see GlobalOptionsMap
+ * @see GlobalOptionDefinitions
  */
-export interface GlobalOptionsMapEntry {
+export interface GlobalOptionDefinitionsEntry {
   pluginId: string;
   option: GlobalOption;
 }
 
 /**
  * A map with all the `GlobalOption`s and which plugin defined them.
  */
-export type GlobalOptionsMap = Map<string, GlobalOptionsMapEntry>;
+export type GlobalOptionDefinitions = Map<string, GlobalOptionDefinitionsEntry>;