@flowscripter/dynamic-cli-framework 1.2.1 → 1.3.0

package/src/command/SingleCommandCliHelpCommand.ts

@@ -107,23 +107,21 @@ abstract class SingleCommandCliAbstractHelpCommand {
         });
       });
     }
-    helpSection.helpEntries.sort((a: HelpEntry, b: HelpEntry) =>
-      a.syntax.localeCompare(b.syntax)
-    );
+    helpSection.helpEntries.sort((a: HelpEntry, b: HelpEntry) => a.syntax.localeCompare(b.syntax));
     return helpSection;
   }
 
-  public async execute(
-    context: Context,
-  ): Promise<void> {
+  public async execute(context: Context): Promise<void> {
     const helpSections: Array<HelpSection> = [];
     helpSections.push({
       title: "Usage",
-      helpEntries: [{
-        syntax: `${context.cliConfig.name || ""}${
-          getSubCommandArgumentsSyntax(this.#defaultCommand)
-        }`,
-      }],
+      helpEntries: [
+        {
+          syntax: `${context.cliConfig.name || ""}${getSubCommandArgumentsSyntax(
+            this.#defaultCommand,
+          )}`,
+        },
+      ],
     });
 
     helpSections.push(
@@ -135,8 +133,7 @@ abstract class SingleCommandCliAbstractHelpCommand {
       ),
     );
 
-    const globalModifierCommands = this.#commandRegistry
-      .getGlobalModifierCommands();
+    const globalModifierCommands = this.#commandRegistry.getGlobalModifierCommands();
     const globalCommands = this.#commandRegistry.getGlobalCommands();
     helpSections.push(
       this.#getAmalgamatedGenericHelpSection(
@@ -148,26 +145,16 @@ abstract class SingleCommandCliAbstractHelpCommand {
       ),
     );
 
-    const printerService = context.getServiceById(
-      PRINTER_SERVICE_ID,
-    ) as PrinterService;
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
     const tableGeneratorService = context.getServiceById(
       TABLE_GENERATOR_SERVICE_ID,
     ) as TableGeneratorService;
 
     helpSections.push(
-      ...getCommandExamplesHelpSections(
-        printerService,
-        context,
-        this.#defaultCommand,
-      ),
+      ...getCommandExamplesHelpSections(printerService, context, this.#defaultCommand),
     );
 
-    await printHelpSections(
-      printerService,
-      tableGeneratorService,
-      helpSections,
-    );
+    await printHelpSections(printerService, tableGeneratorService, helpSections);
   }
 }
 
@@ -176,7 +163,8 @@ abstract class SingleCommandCliAbstractHelpCommand {
  */
 export class SingleCommandCliHelpGlobalCommand
   extends SingleCommandCliAbstractHelpCommand
-  implements GlobalCommand {
+  implements GlobalCommand
+{
   readonly shortAlias = "h";
 }
 
@@ -185,7 +173,8 @@ export class SingleCommandCliHelpGlobalCommand
  */
 export class SingleCommandCliHelpSubCommand
   extends SingleCommandCliAbstractHelpCommand
-  implements SubCommand {
+  implements SubCommand
+{
   public readonly options: ReadonlyArray<Option> = [];
 
   public readonly positionals: ReadonlyArray<Positional> = [];

package/src/command/UsageCommand.ts

@@ -13,23 +13,17 @@ export default class UsageCommand implements GlobalCommand {
 
   readonly #helpCommand: Command;
 
-  public constructor(
-    helpCommand: Command,
-  ) {
+  public constructor(helpCommand: Command) {
     this.#helpCommand = helpCommand;
   }
 
-  public async execute(
-    context: Context,
-  ): Promise<void> {
-    const printerService = context.getServiceById(
-      PRINTER_SERVICE_ID,
-    ) as PrinterService;
+  public async execute(context: Context): Promise<void> {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
 
     await printerService.print(
-      `${printerService.secondary("Try running:")}\n\n  ${
-        printerService.primary(context.cliConfig.name)
-      } --${printerService.primary(this.#helpCommand.name)}\n\n`,
+      `${printerService.secondary("Try running:")}\n\n  ${printerService.primary(
+        context.cliConfig.name,
+      )} --${printerService.primary(this.#helpCommand.name)}\n\n`,
     );
   }
 }

package/src/command/VersionCommand.ts

@@ -11,12 +11,8 @@ export default class VersionCommand implements GlobalCommand {
   readonly description = "Show version information";
   readonly shortAlias = "v";
 
-  public async execute(
-    context: Context,
-  ): Promise<void> {
-    const printerService = context.getServiceById(
-      PRINTER_SERVICE_ID,
-    ) as PrinterService;
+  public async execute(context: Context): Promise<void> {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
     await printerService.print(`${context.cliConfig.version}\n`);
   }
 }

package/src/launcher.ts

@@ -27,7 +27,8 @@ export async function launchSingleCommandCLI(
 
   const mergedOptions: BaseCLIFeatureOptions = {
     ...options,
-    validateAllCommands: (options?.validateAllCommands ?? false) ||
+    validateAllCommands:
+      (options?.validateAllCommands ?? false) ||
       process.env.DYNAMIC_CLI_FRAMEWORK_VALIDATE_ALL !== undefined,
   };
   const cli = new DefaultRuntimeCLI(cliConfig, mergedOptions);
@@ -58,7 +59,8 @@ export async function launchMultiCommandCLI(
 
   const mergedOptions: BaseCLIFeatureOptions = {
     ...options,
-    validateAllCommands: (options?.validateAllCommands ?? false) ||
+    validateAllCommands:
+      (options?.validateAllCommands ?? false) ||
       process.env.DYNAMIC_CLI_FRAMEWORK_VALIDATE_ALL !== undefined,
   };
   const cli = new DefaultRuntimeCLI(cliConfig, mergedOptions);

package/src/runtime/DefaultContext.ts

@@ -7,14 +7,11 @@ import type CLIConfig from "../api/CLIConfig.ts";
 export default class DefaultContext implements Context {
   readonly #serviceInstancesById: Map<string, unknown> = new Map();
 
-  public constructor(readonly cliConfig: CLIConfig) {
-  }
+  public constructor(readonly cliConfig: CLIConfig) {}
 
   public addServiceInstance(id: string, serviceInstance: unknown) {
     if (this.#serviceInstancesById.has(id)) {
-      throw new Error(
-        `Service ID: ${id} duplicates the ID of an existing service`,
-      );
+      throw new Error(`Service ID: ${id} duplicates the ID of an existing service`);
     }
     this.#serviceInstancesById.set(id, serviceInstance);
   }

package/src/runtime/argument/ArgumentTypeGuards.ts

@@ -1,8 +1,6 @@
 import type Argument from "../../api/argument/Argument.ts";
 import type ComplexOption from "../../api/argument/ComplexOption.ts";
 
-export function isComplexOption(
-  argument: Argument | ComplexOption,
-): argument is ComplexOption {
+export function isComplexOption(argument: Argument | ComplexOption): argument is ComplexOption {
   return (argument as ComplexOption).properties !== undefined;
 }

package/src/runtime/command/CommandTypeGuards.ts

@@ -4,27 +4,18 @@ import type GlobalCommand from "../../api/command/GlobalCommand.ts";
 import type GlobalModifierCommand from "../../api/command/GlobalModifierCommand.ts";
 import type Command from "../../api/command/Command.ts";
 
-export function isGroupCommand(
-  command: Command,
-): command is GroupCommand {
+export function isGroupCommand(command: Command): command is GroupCommand {
   return (command as GroupCommand).memberSubCommands !== undefined;
 }
 
-export function isSubCommand(
-  command: Command,
-): command is SubCommand {
+export function isSubCommand(command: Command): command is SubCommand {
   return (command as SubCommand).options !== undefined;
 }
 
-export function isGlobalModifierCommand(
-  command: Command,
-): command is GlobalModifierCommand {
+export function isGlobalModifierCommand(command: Command): command is GlobalModifierCommand {
   return (command as GlobalModifierCommand).executePriority !== undefined;
 }
 
-export function isGlobalCommand(
-  command: Command,
-): command is GlobalCommand {
-  return !isGroupCommand(command) && !isSubCommand(command) &&
-    !isGlobalModifierCommand(command);
+export function isGlobalCommand(command: Command): command is GlobalCommand {
+  return !isGroupCommand(command) && !isSubCommand(command) && !isGlobalModifierCommand(command);
 }

package/src/runtime/command/CommandValidator.ts

@@ -4,9 +4,7 @@ import type GlobalCommand from "../../api/command/GlobalCommand.ts";
 import type Argument from "../../api/argument/Argument.ts";
 import type GroupCommand from "../../api/command/GroupCommand.ts";
 import type SubCommand from "../../api/command/SubCommand.ts";
-import type {
-  ArgumentSingleValueType,
-} from "../../api/argument/ArgumentValueTypes.ts";
+import type { ArgumentSingleValueType } from "../../api/argument/ArgumentValueTypes.ts";
 import {
   ArgumentValueTypeName,
   ComplexValueTypeName,
@@ -49,7 +47,7 @@ function validateValueType(
       }
       break;
     case ArgumentValueTypeName.NUMBER:
-      if ((typeof value !== "number") || !Number.isFinite(value)) {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
         throw new Error(
           `Specified ${
             isDefaultValue ? "default" : isRangeValue ? "range" : "allowable"
@@ -58,7 +56,7 @@ function validateValueType(
       }
       break;
     case ArgumentValueTypeName.INTEGER:
-      if ((typeof value !== "number") || !Number.isInteger(value)) {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
         throw new Error(
           `Specified ${
             isDefaultValue ? "default" : isRangeValue ? "range" : "allowable"
@@ -91,26 +89,25 @@ function isUppercaseAlphaNumericOrUnderscore(value: string): boolean {
 }
 
 function isNameLegal(name: string): boolean {
-  return (name.length > 0) && isAlphaNumericOrDashOrUnderscore(name) &&
-    (name[0] !== "-");
+  return name.length > 0 && isAlphaNumericOrDashOrUnderscore(name) && name[0] !== "-";
 }
 
 function isConfigurationKeyLegal(configurationKey: string): boolean {
-  return (configurationKey.length > 0) &&
+  return (
+    configurationKey.length > 0 &&
     isUppercaseAlphaNumericOrUnderscore(configurationKey) &&
-    !configurationKey[0]!.match(/[0-9]/);
+    !configurationKey[0]!.match(/[0-9]/)
+  );
 }
 
 function validateArgument(argument: Argument, name: string): void {
   if (
-    (argument.type !== ArgumentValueTypeName.NUMBER) &&
-    (argument.type !== ArgumentValueTypeName.INTEGER) &&
-    (argument.type !== ArgumentValueTypeName.STRING) &&
-    (argument.type !== ArgumentValueTypeName.BOOLEAN)
+    argument.type !== ArgumentValueTypeName.NUMBER &&
+    argument.type !== ArgumentValueTypeName.INTEGER &&
+    argument.type !== ArgumentValueTypeName.STRING &&
+    argument.type !== ArgumentValueTypeName.BOOLEAN
   ) {
-    throw new Error(
-      `Illegal type: '${argument.type}' for argument: '${name}'`,
-    );
+    throw new Error(`Illegal type: '${argument.type}' for argument: '${name}'`);
   }
   if (argument.allowableValues) {
     if (argument.type === ArgumentValueTypeName.BOOLEAN) {
@@ -123,10 +120,7 @@ function validateArgument(argument: Argument, name: string): void {
     });
   }
   if (argument.isCaseInsensitive !== undefined) {
-    if (
-      (argument.type === ArgumentValueTypeName.BOOLEAN) &&
-      (argument.isCaseInsensitive === false)
-    ) {
+    if (argument.type === ArgumentValueTypeName.BOOLEAN && argument.isCaseInsensitive === false) {
       throw new Error(
         `Illegal type: '${argument.type}' for argument: '${name}' must always be case insensitive`,
       );
@@ -138,8 +132,8 @@ function validateArgument(argument: Argument, name: string): void {
   }
   if (argument.minValueInclusive !== undefined) {
     if (
-      (argument.type !== ArgumentValueTypeName.NUMBER) &&
-      (argument.type !== ArgumentValueTypeName.INTEGER)
+      argument.type !== ArgumentValueTypeName.NUMBER &&
+      argument.type !== ArgumentValueTypeName.INTEGER
     ) {
       throw new Error(
         `Illegal type: '${argument.type}' for argument: '${name}' with min value specified`,
@@ -150,18 +144,12 @@ function validateArgument(argument: Argument, name: string): void {
         `Illegal combination of allowable values and min value for argument: '${name}'`,
       );
     }
-    validateValueType(
-      argument.type,
-      argument.minValueInclusive,
-      name,
-      false,
-      true,
-    );
+    validateValueType(argument.type, argument.minValueInclusive, name, false, true);
   }
   if (argument.maxValueInclusive !== undefined) {
     if (
-      (argument.type !== ArgumentValueTypeName.NUMBER) &&
-      (argument.type !== ArgumentValueTypeName.INTEGER)
+      argument.type !== ArgumentValueTypeName.NUMBER &&
+      argument.type !== ArgumentValueTypeName.INTEGER
     ) {
       throw new Error(
         `Illegal type: '${argument.type}' for argument: '${name}' with max value specified`,
@@ -172,19 +160,11 @@ function validateArgument(argument: Argument, name: string): void {
         `Illegal combination of allowable values and max value for argument: '${name}'`,
       );
     }
-    validateValueType(
-      argument.type,
-      argument.maxValueInclusive,
-      name,
-      false,
-      true,
-    );
+    validateValueType(argument.type, argument.maxValueInclusive, name, false, true);
   }
 }
 
-function validateSubCommandArgument(
-  subCommandArgument: SubCommandArgument,
-): void {
+function validateSubCommandArgument(subCommandArgument: SubCommandArgument): void {
   if (!isNameLegal(subCommandArgument.name)) {
     throw new Error(`Illegal argument name: '${subCommandArgument.name}'`);
   }
@@ -236,8 +216,7 @@ export default class CommandValidator {
     }
     if (
       globalCommand.shortAlias &&
-      (globalCommand.shortAlias.length !== 1 ||
-        !isAlphaNumeric(globalCommand.shortAlias))
+      (globalCommand.shortAlias.length !== 1 || !isAlphaNumeric(globalCommand.shortAlias))
     ) {
       throw new Error(
         `Illegal short alias: '${globalCommand.shortAlias}' for global command: '${globalCommand.name}'`,
@@ -248,25 +227,16 @@ export default class CommandValidator {
       validateArgument(argument, globalCommand.name);
       if (argument.defaultValue) {
         const invalidArguments: Array<InvalidArgument> = [];
-        validateGlobalCommandArgumentValue(
-          globalCommand,
-          argument.defaultValue,
-          invalidArguments,
-        );
+        validateGlobalCommandArgumentValue(globalCommand, argument.defaultValue, invalidArguments);
         if (invalidArguments.length > 0) {
           throw new Error(
-            `Illegal default value for global command: '${globalCommand.name}' => ${
-              invalidArguments.map((invalidArgument) =>
-                getInvalidArgumentString(invalidArgument, true)
-              ).join(", ")
-            }`,
+            `Illegal default value for global command: '${globalCommand.name}' => ${invalidArguments
+              .map((invalidArgument) => getInvalidArgumentString(invalidArgument, true))
+              .join(", ")}`,
           );
         }
       }
-      this.#validateGlobalCommandArgumentConfigurationKey(
-        globalCommand,
-        argument,
-      );
+      this.#validateGlobalCommandArgumentConfigurationKey(globalCommand, argument);
     }
   }
 
@@ -289,9 +259,7 @@ export default class CommandValidator {
       throw new Error(`Illegal group command name: '${groupCommand.name}'`);
     }
     if (groupCommand.memberSubCommands.length === 0) {
-      throw new Error(
-        `Group command: '${groupCommand.name}' has no member sub-commands`,
-      );
+      throw new Error(`Group command: '${groupCommand.name}' has no member sub-commands`);
     }
     const subCommandNames: Array<string> = [];
     groupCommand.memberSubCommands.forEach((subCommand) => {
@@ -378,16 +346,14 @@ export default class CommandValidator {
         argumentNames.push(positional.name);
 
         if (
-          (i < subCommand.positionals.length - 1) &&
+          i < subCommand.positionals.length - 1 &&
           (positional.isVarargOptional || positional.isVarargMultiple)
         ) {
           throw new Error(
             `Positional: '${positional.name}' for the command: '${subCommand.name}' is defined as a vararg but it is not the last positional argument`,
           );
         }
-        this.#validateSubCommandArgumentConfigurationKey(subCommand, [
-          positional,
-        ]);
+        this.#validateSubCommandArgumentConfigurationKey(subCommand, [positional]);
       }
     }
   }
@@ -399,12 +365,10 @@ export default class CommandValidator {
     const argument = argumentAncestry[argumentAncestry.length - 1]!;
     if (command.enableConfiguration === true) {
       if (
-        (argument.configurationKey !== undefined) &&
+        argument.configurationKey !== undefined &&
         !isConfigurationKeyLegal(argument.configurationKey)
       ) {
-        throw new Error(
-          `Illegal configuration key: '${argument.configurationKey}'`,
-        );
+        throw new Error(`Illegal configuration key: '${argument.configurationKey}'`);
       }
       const configurationKey = getSubCommandArgumentConfigurationKey(
         this.#cliConfig,
@@ -433,12 +397,10 @@ export default class CommandValidator {
   ) {
     if (command.enableConfiguration === true) {
       if (
-        (globalCommandArgument.configurationKey !== undefined) &&
+        globalCommandArgument.configurationKey !== undefined &&
         !isConfigurationKeyLegal(globalCommandArgument.configurationKey)
       ) {
-        throw new Error(
-          `Illegal configuration key: '${globalCommandArgument.configurationKey}'`,
-        );
+        throw new Error(`Illegal configuration key: '${globalCommandArgument.configurationKey}'`);
       }
       const configurationKey = getGlobalCommandArgumentConfigurationKey(
         this.#cliConfig,
@@ -472,24 +434,16 @@ export default class CommandValidator {
       option.shortAlias &&
       (option.shortAlias.length !== 1 || !isAlphaNumeric(option.shortAlias))
     ) {
-      throw new Error(
-        `Illegal short alias: '${option.shortAlias}' for option: '${option.name}'`,
-      );
+      throw new Error(`Illegal short alias: '${option.shortAlias}' for option: '${option.name}'`);
     }
     if (isComplexOption(option)) {
-      this.#validateComplexOption(
-        subCommand,
-        option,
-        currentOptionPaths,
-        allOptionPaths,
-        [...argumentAncestry, option as unknown as SubCommandArgument],
-      );
-    } else {
-      this.#validateOption(option, currentOptionPaths, allOptionPaths);
-      this.#validateSubCommandArgumentConfigurationKey(subCommand, [
+      this.#validateComplexOption(subCommand, option, currentOptionPaths, allOptionPaths, [
         ...argumentAncestry,
-        option,
+        option as unknown as SubCommandArgument,
       ]);
+    } else {
+      this.#validateOption(option, currentOptionPaths, allOptionPaths);
+      this.#validateSubCommandArgumentConfigurationKey(subCommand, [...argumentAncestry, option]);
     }
   }
 
@@ -501,25 +455,19 @@ export default class CommandValidator {
     validateSubCommandArgument(option);
     if (Array.isArray(option.defaultValue) && !option.isArray) {
       throw new Error(
-        `Illegal array default value: '${
-          option.defaultValue.join(",")
-        }' for non-array option: '${option.name}'`,
+        `Illegal array default value: '${option.defaultValue.join(
+          ",",
+        )}' for non-array option: '${option.name}'`,
       );
     }
     if (option.defaultValue) {
       const invalidArguments: Array<InvalidArgument> = [];
-      validateOptionValue(
-        option,
-        option.defaultValue,
-        invalidArguments,
-      );
+      validateOptionValue(option, option.defaultValue, invalidArguments);
       if (invalidArguments.length > 0) {
         throw new Error(
-          `Illegal default value for option: '${option.name}' => ${
-            invalidArguments.map((invalidArgument) =>
-              getInvalidArgumentString(invalidArgument, true)
-            ).join(", ")
-          }`,
+          `Illegal default value for option: '${option.name}' => ${invalidArguments
+            .map((invalidArgument) => getInvalidArgumentString(invalidArgument, true))
+            .join(", ")}`,
         );
       }
     }
@@ -562,32 +510,24 @@ export default class CommandValidator {
     }
     if (Array.isArray(complexOption.defaultValue) && !complexOption.isArray) {
       throw new Error(
-        `Illegal array default value: '${
-          JSON.stringify(complexOption.defaultValue)
-        }' for non-array option: '${complexOption.name}'`,
+        `Illegal array default value: '${JSON.stringify(
+          complexOption.defaultValue,
+        )}' for non-array option: '${complexOption.name}'`,
       );
     }
     if (complexOption.defaultValue) {
       const invalidArguments: Array<InvalidArgument> = [];
-      validateOptionValue(
-        complexOption,
-        complexOption.defaultValue,
-        invalidArguments,
-      );
+      validateOptionValue(complexOption, complexOption.defaultValue, invalidArguments);
       if (invalidArguments.length > 0) {
         throw new Error(
-          `Illegal default value for option: '${complexOption.name}' => ${
-            invalidArguments.map((invalidArgument) =>
-              getInvalidArgumentString(invalidArgument, true)
-            ).join(", ")
-          }`,
+          `Illegal default value for option: '${complexOption.name}' => ${invalidArguments
+            .map((invalidArgument) => getInvalidArgumentString(invalidArgument, true))
+            .join(", ")}`,
         );
       }
     }
     if (complexOption.properties.length === 0) {
-      throw new Error(
-        `Complex option: '${complexOption.name}' has no properties`,
-      );
+      throw new Error(`Complex option: '${complexOption.name}' has no properties`);
     }
     complexOption.properties.forEach((property) => {
       const newCurrentOptionPaths: Array<string> = [];
@@ -596,9 +536,7 @@ export default class CommandValidator {
       });
       if (property.shortAlias) {
         currentOptionPaths.forEach((currentOptionPath) => {
-          newCurrentOptionPaths.push(
-            `${currentOptionPath}.${property.shortAlias}`,
-          );
+          newCurrentOptionPaths.push(`${currentOptionPath}.${property.shortAlias}`);
         });
       }
       this.#validateOptionOrComplexOption(

package/src/runtime/parser.ts

@@ -21,7 +21,7 @@ import type SubCommand from "../api/command/SubCommand.ts";
 const logger = getLogger("parser");
 
 /**
- * A container holding the result of a {@link CommandClause} parsing operation.
+ * A container holding the result of a command clause parsing operation.
  */
 export interface ParseResult {
   /**
@@ -40,9 +40,7 @@ export interface ParseResult {
    * {@link PopulatedArgumentSingleValueType} is for {@link GlobalCommand} values, {@link PopulatedArgumentValues} is for
    * {@link SubCommand} values.
    */
-  readonly populatedArgumentValues:
-    | PopulatedArgumentValues
-    | PopulatedArgumentSingleValueType;
+  readonly populatedArgumentValues: PopulatedArgumentValues | PopulatedArgumentSingleValueType;
 
   /**
    * Any arguments which were invalid.
@@ -72,7 +70,7 @@ export function parseSubCommandClause(
   const invalidArguments: Array<InvalidArgument> = [];
 
   // check if we need to process any arguments at all
-  if ((command.options.length === 0) && (command.positionals.length === 0)) {
+  if (command.options.length === 0 && command.positionals.length === 0) {
     return {
       command,
       groupCommand,
@@ -82,12 +80,11 @@ export function parseSubCommandClause(
     };
   }
 
-  const { populatedArgumentValues, unusedArgs, invalidArgument } =
-    populateSubCommandValues(
-      command,
-      potentialArgs,
-      defaultValues,
-    );
+  const { populatedArgumentValues, unusedArgs, invalidArgument } = populateSubCommandValues(
+    command,
+    potentialArgs,
+    defaultValues,
+  );
 
   if (invalidArgument) {
     invalidArguments.push(invalidArgument);
@@ -172,12 +169,11 @@ export function parseGlobalCommandClause(
     };
   }
 
-  let { populatedArgumentValue, unusedArgs, invalidArgument } =
-    populateGlobalCommandValue(
-      command,
-      potentialArgs,
-      defaultValue,
-    );
+  let { populatedArgumentValue, unusedArgs, invalidArgument } = populateGlobalCommandValue(
+    command,
+    potentialArgs,
+    defaultValue,
+  );
 
   if (invalidArgument) {
     invalidArguments.push(invalidArgument);

package/src/runtime/registry/CommandRegistry.ts

@@ -59,9 +59,7 @@ export default interface CommandRegistry {
   /**
    * Get a registered {@link GlobalModifierCommand} by name.
    */
-  getGlobalModifierCommandByName(
-    name: string,
-  ): GlobalModifierCommand | undefined;
+  getGlobalModifierCommandByName(name: string): GlobalModifierCommand | undefined;
 
   /**
    * Get a registered {@link GlobalModifierCommand} by short alias.
@@ -96,10 +94,7 @@ export default interface CommandRegistry {
   /**
    * Get a map of all registered {@link GlobalModifierCommand} instances by name not provided by a service.
    */
-  getGlobalModifierCommandsByNameNotProvidedByService(): ReadonlyMap<
-    string,
-    GlobalModifierCommand
-  >;
+  getGlobalModifierCommandsByNameNotProvidedByService(): ReadonlyMap<string, GlobalModifierCommand>;
 
   /**
    * Get a map of all registered {@link GlobalModifierCommand} instances by short alias not provided by a service.