@flowscripter/dynamic-cli-framework 1.2.2 → 1.3.1

package/src/runtime/values/argumentValueMerge.ts

@@ -36,12 +36,8 @@ function doClone(
 }
 
 function arrayMerge(
-  override:
-    | Array<PopulatedArgumentSingleValueType>
-    | Array<PopulatedArgumentValues | undefined>,
-  base:
-    | Array<PopulatedArgumentSingleValueType>
-    | Array<PopulatedArgumentValues>,
+  override: Array<PopulatedArgumentSingleValueType> | Array<PopulatedArgumentValues | undefined>,
+  base: Array<PopulatedArgumentSingleValueType> | Array<PopulatedArgumentValues>,
   nestingLevel: number,
 ): Array<PopulatedArgumentSingleValueType> | Array<PopulatedArgumentValues> {
   if (override.length > MAXIMUM_ARGUMENT_ARRAY_SIZE) {
@@ -55,16 +51,13 @@ function arrayMerge(
   override.forEach((argValue, index) => {
     if (Array.isArray(argValue)) {
       throw new Error(
-        `Array of array values discovered, this is not supported: ${
-          JSON.stringify(argValue)
-        }`,
+        `Array of array values discovered, this is not supported: ${JSON.stringify(argValue)}`,
       );
     }
     if (index >= base.length) {
       result.push(
-        doClone(argValue, nestingLevel) as
-          & PopulatedArgumentSingleValueType
-          & PopulatedArgumentValues,
+        doClone(argValue, nestingLevel) as PopulatedArgumentSingleValueType &
+          PopulatedArgumentValues,
       );
     } else {
       result[index] = doMerge(argValue, base[index], nestingLevel) as
@@ -81,9 +74,7 @@ function objectMerge(
   nestingLevel: number,
 ): PopulatedArgumentValues {
   if (nestingLevel > MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH) {
-    throw new Error(
-      `Maximum complex option nesting depth exceeded: ${nestingLevel}`,
-    );
+    throw new Error(`Maximum complex option nesting depth exceeded: ${nestingLevel}`);
   }
 
   nestingLevel++;
@@ -120,15 +111,12 @@ function doMerge(
     | PopulatedArgumentValueType
     | Array<PopulatedArgumentValues | undefined>,
   nestingLevel: number,
-):
-  | PopulatedArgumentValues
-  | PopulatedArgumentValueType
-  | Array<PopulatedArgumentValues> {
+): PopulatedArgumentValues | PopulatedArgumentValueType | Array<PopulatedArgumentValues> {
   if (defaults === undefined) {
     throw new Error(
-      `Undefined value provided in merge: override = ${
-        JSON.stringify(override)
-      }, defaults = undefined`,
+      `Undefined value provided in merge: override = ${JSON.stringify(
+        override,
+      )}, defaults = undefined`,
     );
   }
   if (typeof override !== typeof defaults) {
@@ -147,17 +135,17 @@ function doMerge(
       }
     } // check if we need to convert from single non-string value to single string value
     else if (
-      (typeof override === "string") &&
-      ((typeof defaults == "number") || (typeof defaults == "boolean"))
+      typeof override === "string" &&
+      (typeof defaults == "number" || typeof defaults == "boolean")
     ) {
       defaults = `${defaults}`;
     }
   }
-  if (override !== undefined && (typeof override !== typeof defaults)) {
+  if (override !== undefined && typeof override !== typeof defaults) {
     throw new Error(
-      `Incompatible value types provided in merge: override = ${
-        JSON.stringify(override)
-      }, defaults = ${JSON.stringify(defaults)}`,
+      `Incompatible value types provided in merge: override = ${JSON.stringify(
+        override,
+      )}, defaults = ${JSON.stringify(defaults)}`,
     );
   }
 

package/src/runtime/values/argumentValueValidation.ts

@@ -61,7 +61,7 @@ function validatePrimitiveValue(
   let castValue: string | undefined;
   switch (argument.type) {
     case ArgumentValueTypeName.BOOLEAN:
-      if ((value === true) || (value === false)) {
+      if (value === true || value === false) {
         convertedValue = value;
         break;
       }
@@ -116,14 +116,9 @@ function validatePrimitiveValue(
     let searchValue = convertedValue;
     let allowableValues = argument.allowableValues;
 
-    if (
-      (argument.type === ArgumentValueTypeName.STRING) &&
-      argument.isCaseInsensitive
-    ) {
+    if (argument.type === ArgumentValueTypeName.STRING && argument.isCaseInsensitive) {
       searchValue = (convertedValue as string).toLowerCase();
-      allowableValues = argument.allowableValues.map((v) =>
-        (v as string).toLowerCase()
-      );
+      allowableValues = argument.allowableValues.map((v) => (v as string).toLowerCase());
     }
     if (!allowableValues.includes(searchValue)) {
       return {
@@ -164,12 +159,9 @@ function validatePrimitiveValue(
 
 function validateArrayValue(
   subCommandArgument: SubCommandArgument | ComplexOption,
-  arrayValue: Array<
-    PopulatedArgumentSingleValueType | PopulatedArgumentValues | undefined
-  >,
+  arrayValue: Array<PopulatedArgumentSingleValueType | PopulatedArgumentValues | undefined>,
 ): ArrayValueValidationResult {
-  const convertedArrayValue: Array<ArgumentSingleValueType | ArgumentValues> =
-    [];
+  const convertedArrayValue: Array<ArgumentSingleValueType | ArgumentValues> = [];
 
   for (let i = 0; i < arrayValue.length; i += 1) {
     const singleValue = arrayValue[i];
@@ -185,9 +177,7 @@ function validateArrayValue(
       };
     }
 
-    let validationResult:
-      | SingleValueValidationResult
-      | ObjectValueValidationResult;
+    let validationResult: SingleValueValidationResult | ObjectValueValidationResult;
 
     if (Array.isArray(singleValue)) {
       throw new Error(
@@ -205,10 +195,7 @@ function validateArrayValue(
           },
         };
       }
-      validationResult = validateObjectValue(
-        subCommandArgument as ComplexOption,
-        singleValue,
-      );
+      validationResult = validateObjectValue(subCommandArgument as ComplexOption, singleValue);
     } // if not array and not object, then must be primitive
     else {
       if (isComplexOption(subCommandArgument)) {
@@ -239,9 +226,7 @@ function validateArrayValue(
           invalidArgument: {
             argument: validationResult.invalidArgument.argument,
             name: `[${i}]${
-              validationResult.invalidArgument.name
-                ? validationResult.invalidArgument.name
-                : ""
+              validationResult.invalidArgument.name ? validationResult.invalidArgument.name : ""
             }`,
             value: validationResult.invalidArgument.value,
             reason: validationResult.invalidArgument.reason,
@@ -253,9 +238,7 @@ function validateArrayValue(
           invalidArgument: {
             argument: validationResult.invalidArgument.argument,
             name: `[${i}]${
-              validationResult.invalidArgument.name
-                ? validationResult.invalidArgument.name
-                : ""
+              validationResult.invalidArgument.name ? validationResult.invalidArgument.name : ""
             }`,
             reason: validationResult.invalidArgument.reason,
           },
@@ -339,10 +322,7 @@ function validateObjectValue(
           },
         };
       }
-      validationResult = validatePrimitiveValue(
-        propertyArg as SubCommandArgument,
-        propertyValue,
-      );
+      validationResult = validatePrimitiveValue(propertyArg as SubCommandArgument, propertyValue);
     }
     if (validationResult.validValue !== undefined) {
       convertedObjectValue[propertyArg.name] = validationResult.validValue as
@@ -358,9 +338,7 @@ function validateObjectValue(
           invalidArgument: {
             argument: validationResult.invalidArgument.argument,
             name: `.${propertyArg.name}${
-              validationResult.invalidArgument.name
-                ? validationResult.invalidArgument.name
-                : ""
+              validationResult.invalidArgument.name ? validationResult.invalidArgument.name : ""
             }`,
             value: validationResult.invalidArgument.value,
             reason: validationResult.invalidArgument.reason,
@@ -372,9 +350,7 @@ function validateObjectValue(
           invalidArgument: {
             argument: validationResult.invalidArgument.argument,
             name: `.${propertyArg.name}${
-              validationResult.invalidArgument.name
-                ? validationResult.invalidArgument.name
-                : ""
+              validationResult.invalidArgument.name ? validationResult.invalidArgument.name : ""
             }`,
             reason: validationResult.invalidArgument.reason,
           },
@@ -396,10 +372,7 @@ function doSubCommandArgumentValidation(
   isArray: boolean,
   isOptional: boolean,
   invalidArguments: Array<InvalidArgument>,
-):
-  | PopulatedArgumentValueType
-  | PopulatedArgumentValues
-  | Array<PopulatedArgumentValues> {
+): PopulatedArgumentValueType | PopulatedArgumentValues | Array<PopulatedArgumentValues> {
   // if there is a value, check if it is valid
   if (value !== undefined) {
     let validationResult;
@@ -436,10 +409,7 @@ function doSubCommandArgumentValidation(
         });
         return undefined;
       }
-      validationResult = validatePrimitiveValue(
-        argument as SubCommandArgument,
-        value,
-      );
+      validationResult = validatePrimitiveValue(argument as SubCommandArgument, value);
     }
 
     if (validationResult.invalidArgument !== undefined) {
@@ -447,9 +417,7 @@ function doSubCommandArgumentValidation(
         validationResult.invalidArgument = {
           argument: validationResult.invalidArgument.argument,
           name: `${argument.name}${
-            validationResult.invalidArgument.name
-              ? validationResult.invalidArgument.name
-              : ""
+            validationResult.invalidArgument.name ? validationResult.invalidArgument.name : ""
           }`,
           value: validationResult.invalidArgument.value,
           reason: validationResult.invalidArgument.reason,
@@ -458,9 +426,7 @@ function doSubCommandArgumentValidation(
         validationResult.invalidArgument = {
           argument: validationResult.invalidArgument.argument,
           name: `${argument.name}${
-            validationResult.invalidArgument.name
-              ? validationResult.invalidArgument.name
-              : ""
+            validationResult.invalidArgument.name ? validationResult.invalidArgument.name : ""
           }`,
           reason: validationResult.invalidArgument.reason,
         };
@@ -473,10 +439,7 @@ function doSubCommandArgumentValidation(
     }
     if (argument.validate && validationResult.validValue !== undefined) {
       const customError = argument.validate(
-        validationResult.validValue as
-          | ArgumentValueType
-          | ArgumentValues
-          | Array<ArgumentValues>,
+        validationResult.validValue as ArgumentValueType | ArgumentValues | Array<ArgumentValues>,
       );
       if (customError !== undefined) {
         invalidArguments.push({
@@ -520,10 +483,7 @@ export function validateOptionValue(
     | PopulatedArgumentValues
     | Array<PopulatedArgumentValues | undefined>,
   invalidArguments: Array<InvalidArgument>,
-):
-  | PopulatedArgumentValueType
-  | PopulatedArgumentValues
-  | Array<PopulatedArgumentValues> {
+): PopulatedArgumentValueType | PopulatedArgumentValues | Array<PopulatedArgumentValues> {
   return doSubCommandArgumentValidation(
     option,
     value,
@@ -572,10 +532,7 @@ export function validateGlobalCommandArgumentValue(
 
   // if there is a value, check if it is valid
   if (value !== undefined) {
-    const validationResult = validatePrimitiveValue(
-      globalCommandArgument,
-      value,
-    );
+    const validationResult = validatePrimitiveValue(globalCommandArgument, value);
 
     if (validationResult.invalidArgument) {
       if (validationResult.invalidArgument.value !== undefined) {
@@ -595,10 +552,7 @@ export function validateGlobalCommandArgumentValue(
       return undefined;
     }
 
-    if (
-      globalCommandArgument.validate &&
-      validationResult.validValue !== undefined
-    ) {
+    if (globalCommandArgument.validate && validationResult.validValue !== undefined) {
       const customError = globalCommandArgument.validate(
         validationResult.validValue as ArgumentValueType,
       );
@@ -632,7 +586,7 @@ export function getInvalidArgumentString(
   skipArgName: boolean,
 ): string {
   let nameString = "";
-  if (!skipArgName && (invalidArgument.name !== undefined)) {
+  if (!skipArgName && invalidArgument.name !== undefined) {
     nameString = invalidArgument.name;
   }
   let valueString = "";

package/src/runtime/values/globalCommandValuePopulation.ts

@@ -1,11 +1,7 @@
 import type GlobalCommand from "../../api/command/GlobalCommand.ts";
 import type { GlobalCommandValuePopulationResult } from "./ValuePopulationResult.ts";
-import {
-  ArgumentValueTypeName,
-} from "../../api/argument/ArgumentValueTypes.ts";
-import type {
-  PopulatedArgumentSingleValueType,
-} from "../../api/argument/ArgumentValueTypes.ts";
+import { ArgumentValueTypeName } from "../../api/argument/ArgumentValueTypes.ts";
+import type { PopulatedArgumentSingleValueType } from "../../api/argument/ArgumentValueTypes.ts";
 import getLogger from "../../util/logger.ts";
 import { InvalidArgumentReason } from "../../api/RunResult.ts";
 
@@ -24,10 +20,9 @@ export default function populateGlobalCommandValue(
   defaultValue: PopulatedArgumentSingleValueType,
 ): GlobalCommandValuePopulationResult {
   logger.debug(() => {
-    const message =
-      `Populating value for global command: '${globalCommand.name}' using potential args: ${
-        potentialArgs.join(" ")
-      }`;
+    const message = `Populating value for global command: '${globalCommand.name}' using potential args: ${potentialArgs.join(
+      " ",
+    )}`;
     if (defaultValue !== undefined) {
       return `${message} and configured value: '${defaultValue}'`;
     }
@@ -51,10 +46,7 @@ export default function populateGlobalCommandValue(
     if (argument.type === ArgumentValueTypeName.BOOLEAN) {
       const firstPotentialArgLower = firstPotentialArg!.toLowerCase();
 
-      if (
-        (firstPotentialArgLower !== "true") &&
-        (firstPotentialArgLower !== "false")
-      ) {
+      if (firstPotentialArgLower !== "true" && firstPotentialArgLower !== "false") {
         // ...instead, use the fact that the argument is present as the value true
         return {
           populatedArgumentValue: "true",
@@ -67,9 +59,8 @@ export default function populateGlobalCommandValue(
     unusedArgs = potentialArgs.slice(1);
   } // check if argument type is boolean and therefore command being specified is an implicit value of true
   else if (
-    (argument.type === ArgumentValueTypeName.BOOLEAN) &&
-    ((populatedArgumentValue === undefined) ||
-      (argument.defaultValue === false))
+    argument.type === ArgumentValueTypeName.BOOLEAN &&
+    (populatedArgumentValue === undefined || argument.defaultValue === false)
   ) {
     return {
       populatedArgumentValue: "true",
@@ -78,7 +69,7 @@ export default function populateGlobalCommandValue(
   }
 
   // check if there is no value and the global command argument is not optional
-  if ((populatedArgumentValue === undefined) && !argument.isOptional) {
+  if (populatedArgumentValue === undefined && !argument.isOptional) {
     return {
       populatedArgumentValue,
       unusedArgs,

package/src/runtime/values/subCommandValuePopulation.ts

@@ -11,14 +11,9 @@ import getLogger from "../../util/logger.ts";
 import argumentValueMerge from "./argumentValueMerge.ts";
 import type { SubCommandValuePopulationResult } from "./ValuePopulationResult.ts";
 import type ComplexOption from "../../api/argument/ComplexOption.ts";
-import {
-  MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH,
-} from "../../api/argument/ComplexOption.ts";
+import { MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH } from "../../api/argument/ComplexOption.ts";
 import { isComplexOption } from "../argument/ArgumentTypeGuards.ts";
-import {
-  type InvalidArgument,
-  InvalidArgumentReason,
-} from "../../api/RunResult.ts";
+import { type InvalidArgument, InvalidArgumentReason } from "../../api/RunResult.ts";
 import { MAXIMUM_ARGUMENT_ARRAY_SIZE } from "../../api/argument/SubCommandArgument.ts";
 
 const logger = getLogger("subCommandValuePopulation");
@@ -150,10 +145,7 @@ class ParseContext {
     this.currentOption = undefined;
 
     // split up the path into elements
-    const complexPathElements = optionPath.split(
-      ".",
-      MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH + 1,
-    );
+    const complexPathElements = optionPath.split(".", MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH + 1);
 
     // check nesting depth
     if (complexPathElements.length > MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH) {
@@ -179,10 +171,9 @@ class ParseContext {
 
       // look for array index
       if (complexPathElement.endsWith("]")) {
-        [complexPathElement, arrayIndexString] = complexPathElement.slice(
-          0,
-          complexPathElement.length - 1,
-        ).split("[") as [string, string | undefined];
+        [complexPathElement, arrayIndexString] = complexPathElement
+          .slice(0, complexPathElement.length - 1)
+          .split("[") as [string, string | undefined];
       }
 
       let lookupPath = this.subCommand.name;
@@ -235,9 +226,10 @@ class ParseContext {
           });
           this.optionLookupMapsByPath.set(lookupPath, lookupMap);
         }
-        option = this.optionLookupMapsByPath.get(lookupPath)!.get(
-          complexPathElement,
-        ) as Option | ComplexOption | undefined;
+        option = this.optionLookupMapsByPath.get(lookupPath)!.get(complexPathElement) as
+          | Option
+          | ComplexOption
+          | undefined;
 
         // now we are parsing properties of complex options it is an error if we cannot match an option name or alias
         if (option === undefined) {
@@ -272,7 +264,7 @@ class ParseContext {
       }
 
       // check for indexing when not allowed
-      if (!option.isArray && (arrayIndex !== undefined)) {
+      if (!option.isArray && arrayIndex !== undefined) {
         this.invalidArgument = {
           argument: option,
           name: optionPath,
@@ -282,15 +274,10 @@ class ParseContext {
         return false;
       }
 
-      if (
-        (currentValue as PopulatedArgumentValues)[complexPathElement] ===
-          undefined
-      ) {
+      if ((currentValue as PopulatedArgumentValues)[complexPathElement] === undefined) {
         // ensure we have a placeholder value
         if (option.isArray) {
-          currentValue =
-            (currentValue as PopulatedArgumentValues)[complexPathElement] =
-              [];
+          currentValue = (currentValue as PopulatedArgumentValues)[complexPathElement] = [];
 
           if (isComplexOption(option)) {
             // if we are retrieving a property by name only use the last entry in the array by default
@@ -302,9 +289,7 @@ class ParseContext {
             currentValue = currentValue[index] = {};
           }
         } else if (isComplexOption(option)) {
-          currentValue =
-            (currentValue as PopulatedArgumentValues)[complexPathElement] =
-              {};
+          currentValue = (currentValue as PopulatedArgumentValues)[complexPathElement] = {};
         }
       } else {
         currentValue = (currentValue as PopulatedArgumentValues)[
@@ -318,7 +303,7 @@ class ParseContext {
             index = arrayIndex;
           }
 
-          if ((currentValue[index] === undefined) && isComplexOption(option)) {
+          if (currentValue[index] === undefined && isComplexOption(option)) {
             // ensure we have a placeholder value
             currentValue = currentValue[index] = {};
           } else {
@@ -380,13 +365,11 @@ class ParseContext {
       // if on last path element, set the value
       if (i === optionPath.length - 1) {
         if (typeof pathElement === "string") {
-          const currentValue =
-            (optionValue as PopulatedArgumentValues)[pathElement as string];
+          const currentValue = (optionValue as PopulatedArgumentValues)[pathElement as string];
 
           // if we haven't populated the argument value before...
           if (currentValue === undefined) {
-            (optionValue as PopulatedArgumentValues)[pathElement as string] =
-              value;
+            (optionValue as PopulatedArgumentValues)[pathElement as string] = value;
           } // if we have already populated the argument value as an array...
           else if (Array.isArray(currentValue)) {
             if (currentValue.length === MAXIMUM_ARGUMENT_ARRAY_SIZE) {
@@ -399,9 +382,7 @@ class ParseContext {
               return false;
             }
             // push the new value
-            (currentValue as Array<PopulatedArgumentSingleValueType>).push(
-              value,
-            );
+            (currentValue as Array<PopulatedArgumentSingleValueType>).push(value);
           } // else the value to add would make an array where it is not allowed
           else {
             this.invalidArgument = {
@@ -414,9 +395,9 @@ class ParseContext {
           }
         } else {
           // set the new value on the array
-          (optionValue as Array<
-            PopulatedArgumentValueType | PopulatedArgumentValues
-          >)[pathElement as number] = value;
+          (optionValue as Array<PopulatedArgumentValueType | PopulatedArgumentValues>)[
+            pathElement as number
+          ] = value;
         }
       } // otherwise continue to navigate the path
       else {
@@ -429,16 +410,15 @@ class ParseContext {
               | PopulatedArgumentValues
               | PopulatedArgumentValueType;
           } else {
-            optionValue =
-              (optionValue as PopulatedArgumentValues)[pathElement as string] as
-                | Array<PopulatedArgumentValues>
-                | PopulatedArgumentValues
-                | PopulatedArgumentValueType;
+            optionValue = (optionValue as PopulatedArgumentValues)[pathElement as string] as
+              | Array<PopulatedArgumentValues>
+              | PopulatedArgumentValues
+              | PopulatedArgumentValueType;
           }
         } else {
-          optionValue = (optionValue as Array<
-            PopulatedArgumentSingleValueType | PopulatedArgumentValues
-          >)[pathElement as number];
+          optionValue = (
+            optionValue as Array<PopulatedArgumentSingleValueType | PopulatedArgumentValues>
+          )[pathElement as number];
         }
       }
     }
@@ -459,8 +439,7 @@ class ParseContext {
    * @param value the value to attempt to set.
    */
   setPositionalValue(value: ArgumentSingleValueType): boolean {
-    const positional = this.subCommand
-      .positionals[this.currentPositionalIndex]!;
+    const positional = this.subCommand.positionals[this.currentPositionalIndex]!;
     const currentValue = this.populatedArgumentValues[positional.name];
 
     // if we haven't populated the argument value before...
@@ -483,7 +462,7 @@ class ParseContext {
         return false;
       }
       this.populatedArgumentValues[positional.name] = [
-        ...currentValue as Array<PopulatedArgumentSingleValueType>,
+        ...(currentValue as Array<PopulatedArgumentSingleValueType>),
         value,
       ] as Array<PopulatedArgumentSingleValueType>;
     }
@@ -509,7 +488,8 @@ class ParseContext {
       // assume the boolean value was implicitly `true` and treat
       // the potential arg as a following option arg or positional value
       if (
-        (potentialArg !== "true") && (potentialArg !== "false") &&
+        potentialArg !== "true" &&
+        potentialArg !== "false" &&
         this.currentOption!.type === ArgumentValueTypeName.BOOLEAN
       ) {
         // Set the value to implicit value of true and return ony error.
@@ -536,8 +516,11 @@ class ParseContext {
 
         // check for option AND value
         if (potentialOptionPath.includes("=")) {
-          [potentialOptionPath, potentialOptionValue] = potentialOptionPath
-            .split(/=(.*)/) as [string, string | undefined, ...string[]];
+          [potentialOptionPath, potentialOptionValue] = potentialOptionPath.split(/=(.*)/) as [
+            string,
+            string | undefined,
+            ...string[],
+          ];
 
           // check for illegal syntax e.g. --optionName=
           if (potentialOptionValue === "") {
@@ -608,14 +591,11 @@ export default function populateSubCommandValues(
   defaultValues: PopulatedArgumentValues | undefined,
 ): SubCommandValuePopulationResult {
   logger.debug(() => {
-    const message =
-      `Populating values for sub-command: '${subCommand.name}' using potential args: ${
-        potentialArgs.join(" ")
-      }`;
+    const message = `Populating values for sub-command: '${subCommand.name}' using potential args: ${potentialArgs.join(
+      " ",
+    )}`;
     if (defaultValues !== undefined) {
-      return `${message} and configured values: ${
-        JSON.stringify(defaultValues)
-      }`;
+      return `${message} and configured values: ${JSON.stringify(defaultValues)}`;
     }
     return message;
   });
@@ -668,10 +648,7 @@ export default function populateSubCommandValues(
   // merge the configured values with the parsed values
   let populatedArgumentValues = parseContext.populatedArgumentValues;
   if (defaultValues) {
-    populatedArgumentValues = argumentValueMerge(
-      populatedArgumentValues,
-      defaultValues,
-    );
+    populatedArgumentValues = argumentValueMerge(populatedArgumentValues, defaultValues);
   }
 
   return {

package/src/service/argumentPrompter/ArgumentPrompterServiceProvider.ts

@@ -1,22 +1,15 @@
 import type Context from "../../api/Context.ts";
-import type {
-  ServiceInfo,
-  ServiceProvider,
-} from "../../api/service/ServiceProvider.ts";
+import type { ServiceInfo, ServiceProvider } from "../../api/service/ServiceProvider.ts";
 import type ArgumentPrompterService from "../../api/service/core/ArgumentPrompterService.ts";
 import { ARGUMENT_PROMPTER_SERVICE_ID } from "../../api/service/core/ArgumentPrompterService.ts";
 import type CLIConfig from "../../api/CLIConfig.ts";
 
-export default class ArgumentPrompterServiceProvider
-  implements ServiceProvider {
+export default class ArgumentPrompterServiceProvider implements ServiceProvider {
   readonly serviceId: string = ARGUMENT_PROMPTER_SERVICE_ID;
   readonly servicePriority: number;
   readonly argumentPrompterService: ArgumentPrompterService;
 
-  public constructor(
-    servicePriority: number,
-    argumentPrompterService: ArgumentPrompterService,
-  ) {
+  public constructor(servicePriority: number, argumentPrompterService: ArgumentPrompterService) {
     this.servicePriority = servicePriority;
     this.argumentPrompterService = argumentPrompterService;
   }