@flowscripter/dynamic-cli-framework 2.5.0 → 3.0.1

package/src/runtime/runner.ts

@@ -4,10 +4,10 @@ import { RunState } from "@flowscripter/dynamic-cli-framework-api";
 import type { CommandRegistry } from "@flowscripter/dynamic-cli-framework-api";
 import { isGlobalCommand, isSubCommand } from "./command/CommandTypeGuards.ts";
 import type {
-  ArgumentSingleValueType,
-  ArgumentValues,
-  PopulatedArgumentSingleValueType,
-  PopulatedArgumentValues,
+  SingleValueType,
+  Values,
+  PopulatedSingleValueType,
+  PopulatedValues,
 } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../util/logger.ts";
 import {
@@ -98,14 +98,11 @@ async function executeParsedCommand(
       configurationServiceProvider.setCommandKeyValueScope(parseResult.command.name);
     }
     if (isSubCommand(parseResult.command)) {
-      await parseResult.command.execute(
-        context,
-        parseResult.populatedArgumentValues as ArgumentValues,
-      );
+      await parseResult.command.execute(context, parseResult.populatedArgumentValues as Values);
     } else {
       await (parseResult.command as GlobalCommand).execute(
         context,
-        parseResult.populatedArgumentValues as ArgumentSingleValueType,
+        parseResult.populatedArgumentValues as SingleValueType,
       );
     }
     if (
@@ -174,7 +171,7 @@ async function findAndExecuteGlobalModifierCommands(
         : undefined;
       const parseResult = parseGlobalCommandClause(
         globalModifierCommandClause,
-        defaultArgumentValues as PopulatedArgumentSingleValueType,
+        defaultArgumentValues as PopulatedSingleValueType,
       );
 
       if (parseResult.invalidArguments.length > 0) {
@@ -219,7 +216,7 @@ async function findAndExecuteGlobalModifierCommands(
           command: globalModifierCommand,
           potentialArgs: [],
         },
-        defaultArgumentValues as PopulatedArgumentSingleValueType,
+        defaultArgumentValues as PopulatedSingleValueType,
       );
 
       if (parseResult.invalidArguments.length > 0) {
@@ -300,12 +297,12 @@ async function findAndExecuteNonModifierCommand(
     if (isGlobalCommand(scanResult.nonModifierCommandClause.command)) {
       parseResult = parseGlobalCommandClause(
         scanResult.nonModifierCommandClause,
-        defaultArgumentValues as PopulatedArgumentSingleValueType,
+        defaultArgumentValues as PopulatedSingleValueType,
       );
     } else {
       parseResult = parseSubCommandClause(
         scanResult.nonModifierCommandClause,
-        defaultArgumentValues as PopulatedArgumentValues,
+        defaultArgumentValues as PopulatedValues,
       );
     }
 
@@ -345,7 +342,7 @@ async function findAndExecuteNonModifierCommand(
               command: nonModifierCommand,
               potentialArgs: [],
             },
-            defaultArgumentValues as PopulatedArgumentSingleValueType,
+            defaultArgumentValues as PopulatedSingleValueType,
           );
         } else {
           parseResult = parseSubCommandClause(
@@ -353,7 +350,7 @@ async function findAndExecuteNonModifierCommand(
               command: nonModifierCommand,
               potentialArgs: [],
             },
-            defaultArgumentValues as PopulatedArgumentValues,
+            defaultArgumentValues as PopulatedValues,
           );
         }
 
@@ -430,7 +427,7 @@ async function findAndExecuteDefaultNonModifierCommand(
           command: defaultNonModifierCommand,
           potentialArgs: [...argSequence],
         },
-        defaultArgumentValues as PopulatedArgumentSingleValueType,
+        defaultArgumentValues as PopulatedSingleValueType,
       );
     } else {
       parseResult = parseSubCommandClause(
@@ -438,7 +435,7 @@ async function findAndExecuteDefaultNonModifierCommand(
           command: defaultNonModifierCommand,
           potentialArgs: [...argSequence],
         },
-        defaultArgumentValues as PopulatedArgumentValues,
+        defaultArgumentValues as PopulatedValues,
       );
     }
 
@@ -470,7 +467,7 @@ async function findAndExecuteDefaultNonModifierCommand(
           command: defaultNonModifierCommand,
           potentialArgs: [],
         },
-        defaultArgumentValues as PopulatedArgumentSingleValueType,
+        defaultArgumentValues as PopulatedSingleValueType,
       );
     } else {
       parseResult = parseSubCommandClause(
@@ -478,7 +475,7 @@ async function findAndExecuteDefaultNonModifierCommand(
           command: defaultNonModifierCommand,
           potentialArgs: [],
         },
-        defaultArgumentValues as PopulatedArgumentValues,
+        defaultArgumentValues as PopulatedValues,
       );
     }
 

package/src/runtime/values/ValuePopulationResult.ts

@@ -1,6 +1,6 @@
 import type {
-  PopulatedArgumentSingleValueType,
-  PopulatedArgumentValues,
+  PopulatedSingleValueType,
+  PopulatedValues,
 } from "@flowscripter/dynamic-cli-framework-api";
 import type { InvalidArgument } from "@flowscripter/dynamic-cli-framework-api";
 
@@ -26,7 +26,7 @@ export interface SubCommandValuePopulationResult extends ValuePopulationResult {
   /**
    * Populated argument values.
    */
-  readonly populatedArgumentValues: PopulatedArgumentValues;
+  readonly populatedArgumentValues: PopulatedValues;
 }
 
 /**
@@ -36,5 +36,5 @@ export interface GlobalCommandValuePopulationResult extends ValuePopulationResul
   /**
    * Populated argument value.
    */
-  readonly populatedArgumentValue: PopulatedArgumentSingleValueType;
+  readonly populatedArgumentValue: PopulatedSingleValueType;
 }

package/src/runtime/values/argumentValueMerge.ts

@@ -1,25 +1,21 @@
 import type {
-  ArgumentSingleValueType,
-  ArgumentValues,
-  PopulatedArgumentSingleValueType,
-  PopulatedArgumentValues,
-  PopulatedArgumentValueType,
+  SingleValueType,
+  Values,
+  PopulatedSingleValueType,
+  PopulatedValues,
+  PopulatedValueType,
 } from "@flowscripter/dynamic-cli-framework-api";
 import { MAXIMUM_ARGUMENT_ARRAY_SIZE } from "@flowscripter/dynamic-cli-framework-api";
 import { MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH } from "@flowscripter/dynamic-cli-framework-api";
 
 function doClone(
   source:
-    | PopulatedArgumentValueType
-    | PopulatedArgumentValues
-    | Array<PopulatedArgumentValues | undefined>
-    | Array<PopulatedArgumentSingleValueType>,
+    | PopulatedValueType
+    | PopulatedValues
+    | Array<PopulatedValues | undefined>
+    | Array<PopulatedSingleValueType>,
   nestingLevel: number,
-):
-  | PopulatedArgumentValueType
-  | PopulatedArgumentValues
-  | Array<PopulatedArgumentValues>
-  | Array<PopulatedArgumentSingleValueType> {
+): PopulatedValueType | PopulatedValues | Array<PopulatedValues> | Array<PopulatedSingleValueType> {
   if (source === undefined) {
     return source;
   }
@@ -36,10 +32,10 @@ function doClone(
 }
 
 function arrayMerge(
-  override: Array<PopulatedArgumentSingleValueType> | Array<PopulatedArgumentValues | undefined>,
-  base: Array<PopulatedArgumentSingleValueType> | Array<PopulatedArgumentValues>,
+  override: Array<PopulatedSingleValueType> | Array<PopulatedValues | undefined>,
+  base: Array<PopulatedSingleValueType> | Array<PopulatedValues>,
   nestingLevel: number,
-): Array<PopulatedArgumentSingleValueType> | Array<PopulatedArgumentValues> {
+): Array<PopulatedSingleValueType> | Array<PopulatedValues> {
   if (override.length > MAXIMUM_ARGUMENT_ARRAY_SIZE) {
     throw new Error(`Maximum array size exceeded: ${override.length}`);
   }
@@ -55,31 +51,28 @@ function arrayMerge(
       );
     }
     if (index >= base.length) {
-      result.push(
-        doClone(argValue, nestingLevel) as PopulatedArgumentSingleValueType &
-          PopulatedArgumentValues,
-      );
+      result.push(doClone(argValue, nestingLevel) as PopulatedSingleValueType & PopulatedValues);
     } else {
       result[index] = doMerge(argValue, base[index], nestingLevel) as
-        | PopulatedArgumentSingleValueType
-        | PopulatedArgumentValues;
+        | PopulatedSingleValueType
+        | PopulatedValues;
     }
   });
   return result;
 }
 
 function objectMerge(
-  override: PopulatedArgumentValues,
-  base: PopulatedArgumentValues,
+  override: PopulatedValues,
+  base: PopulatedValues,
   nestingLevel: number,
-): PopulatedArgumentValues {
+): PopulatedValues {
   if (nestingLevel > MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH) {
     throw new Error(`Maximum complex option nesting depth exceeded: ${nestingLevel}`);
   }
 
   nestingLevel++;
 
-  const result: PopulatedArgumentValues = {};
+  const result: PopulatedValues = {};
 
   Object.keys(override).forEach((argName) => {
     if (base[argName] === undefined) {
@@ -102,16 +95,10 @@ function objectMerge(
 }
 
 function doMerge(
-  override:
-    | PopulatedArgumentValues
-    | PopulatedArgumentValueType
-    | Array<PopulatedArgumentValues | undefined>,
-  defaults:
-    | PopulatedArgumentValues
-    | PopulatedArgumentValueType
-    | Array<PopulatedArgumentValues | undefined>,
+  override: PopulatedValues | PopulatedValueType | Array<PopulatedValues | undefined>,
+  defaults: PopulatedValues | PopulatedValueType | Array<PopulatedValues | undefined>,
   nestingLevel: number,
-): PopulatedArgumentValues | PopulatedArgumentValueType | Array<PopulatedArgumentValues> {
+): PopulatedValues | PopulatedValueType | Array<PopulatedValues> {
   if (defaults === undefined) {
     throw new Error(
       `Undefined value provided in merge: override = ${JSON.stringify(
@@ -123,15 +110,15 @@ function doMerge(
     // check if we need to convert from single value to array
     if (Array.isArray(override)) {
       if (typeof defaults === "object") {
-        defaults = [defaults as ArgumentValues];
+        defaults = [defaults as Values];
       } else {
-        defaults = [defaults as ArgumentSingleValueType];
+        defaults = [defaults as SingleValueType];
       }
     } else if (Array.isArray(defaults)) {
       if (typeof override === "object") {
-        override = [override as PopulatedArgumentValues];
+        override = [override as PopulatedValues];
       } else {
-        override = [override as PopulatedArgumentSingleValueType];
+        override = [override as PopulatedSingleValueType];
       }
     } // check if we need to convert from single non-string value to single string value
     else if (
@@ -151,15 +138,11 @@ function doMerge(
 
   // check if override is an array
   if (Array.isArray(override)) {
-    return arrayMerge(
-      override,
-      defaults as Array<ArgumentValues> | Array<ArgumentSingleValueType>,
-      nestingLevel,
-    );
+    return arrayMerge(override, defaults as Array<Values> | Array<SingleValueType>, nestingLevel);
   }
   // check if override is an object
   if (typeof override === "object") {
-    return objectMerge(override, defaults as ArgumentValues, nestingLevel);
+    return objectMerge(override, defaults as Values, nestingLevel);
   }
 
   // check if override is undefined so we should use default
@@ -182,8 +165,8 @@ function doMerge(
  * @param defaults the values to use unless they are overridden in `override`.
  */
 export default function argumentValueMerge(
-  override: PopulatedArgumentValues,
-  defaults: PopulatedArgumentValues,
-): PopulatedArgumentValues {
-  return doMerge(override, defaults, 0) as PopulatedArgumentValues;
+  override: PopulatedValues,
+  defaults: PopulatedValues,
+): PopulatedValues {
+  return doMerge(override, defaults, 0) as PopulatedValues;
 }

package/src/runtime/values/argumentValueValidation.ts

@@ -1,15 +1,12 @@
 import type {
-  ArgumentSingleValueType,
-  ArgumentValues,
-  ArgumentValueType,
-  PopulatedArgumentSingleValueType,
-  PopulatedArgumentValues,
-  PopulatedArgumentValueType,
-} from "@flowscripter/dynamic-cli-framework-api";
-import {
-  ArgumentValueTypeName,
-  ComplexValueTypeName,
+  SingleValueType,
+  Values,
+  ValueType,
+  PopulatedSingleValueType,
+  PopulatedValues,
+  PopulatedValueType,
 } from "@flowscripter/dynamic-cli-framework-api";
+import { ValueTypeName, ComplexValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Positional } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { ComplexOption } from "@flowscripter/dynamic-cli-framework-api";
@@ -25,15 +22,15 @@ interface ValidationResult {
 }
 
 interface SingleValueValidationResult extends ValidationResult {
-  validValue?: ArgumentSingleValueType;
+  validValue?: SingleValueType;
 }
 
 interface ArrayValueValidationResult extends ValidationResult {
-  validValue?: Array<ArgumentSingleValueType | ArgumentValues>;
+  validValue?: Array<SingleValueType | Values>;
 }
 
 interface ObjectValueValidationResult extends ValidationResult {
-  validValue?: ArgumentValues;
+  validValue?: Values;
 }
 
 /**
@@ -44,7 +41,7 @@ interface ObjectValueValidationResult extends ValidationResult {
  */
 function validatePrimitiveValue(
   argument: Argument,
-  value: PopulatedArgumentSingleValueType,
+  value: PopulatedSingleValueType,
 ): SingleValueValidationResult {
   let convertedValue;
 
@@ -60,7 +57,7 @@ function validatePrimitiveValue(
   // type check and conversion
   let castValue: string | undefined;
   switch (argument.type) {
-    case ArgumentValueTypeName.BOOLEAN:
+    case ValueTypeName.BOOLEAN:
       if (value === true || value === false) {
         convertedValue = value;
         break;
@@ -80,7 +77,7 @@ function validatePrimitiveValue(
       }
       convertedValue = castValue === "true";
       break;
-    case ArgumentValueTypeName.INTEGER:
+    case ValueTypeName.INTEGER:
       if (!Number.isInteger(Number(value))) {
         return {
           invalidArgument: {
@@ -92,7 +89,7 @@ function validatePrimitiveValue(
       }
       convertedValue = Number(value);
       break;
-    case ArgumentValueTypeName.NUMBER:
+    case ValueTypeName.NUMBER:
       if (!Number.isFinite(Number(value))) {
         return {
           invalidArgument: {
@@ -104,7 +101,7 @@ function validatePrimitiveValue(
       }
       convertedValue = Number(value);
       break;
-    case ArgumentValueTypeName.STRING:
+    case ValueTypeName.STRING:
     default:
       convertedValue = String(value);
       break;
@@ -116,7 +113,7 @@ function validatePrimitiveValue(
     let searchValue = convertedValue;
     let allowableValues = argument.allowableValues;
 
-    if (argument.type === ArgumentValueTypeName.STRING && argument.isCaseInsensitive) {
+    if (argument.type === ValueTypeName.STRING && argument.isCaseInsensitive) {
       searchValue = (convertedValue as string).toLowerCase();
       allowableValues = argument.allowableValues.map((v) => (v as string).toLowerCase());
     }
@@ -159,9 +156,9 @@ function validatePrimitiveValue(
 
 function validateArrayValue(
   subCommandArgument: SubCommandArgument | ComplexOption,
-  arrayValue: Array<PopulatedArgumentSingleValueType | PopulatedArgumentValues | undefined>,
+  arrayValue: Array<PopulatedSingleValueType | PopulatedValues | undefined>,
 ): ArrayValueValidationResult {
-  const convertedArrayValue: Array<ArgumentSingleValueType | ArgumentValues> = [];
+  const convertedArrayValue: Array<SingleValueType | Values> = [];
 
   for (let i = 0; i < arrayValue.length; i += 1) {
     const singleValue = arrayValue[i];
@@ -253,9 +250,9 @@ function validateArrayValue(
 
 function validateObjectValue(
   argument: ComplexOption,
-  objectValue: PopulatedArgumentValues,
+  objectValue: PopulatedValues,
 ): ObjectValueValidationResult {
-  const convertedObjectValue: ArgumentValues = {};
+  const convertedObjectValue: Values = {};
 
   for (let i = 0; i < argument.properties.length; i++) {
     const propertyArg = argument.properties[i]!;
@@ -307,7 +304,7 @@ function validateObjectValue(
       }
       validationResult = validateObjectValue(
         propertyArg as ComplexOption,
-        propertyValue as PopulatedArgumentValues,
+        propertyValue as PopulatedValues,
       );
     } // if not array and not object, then must be primitive
     else {
@@ -326,9 +323,9 @@ function validateObjectValue(
     }
     if (validationResult.validValue !== undefined) {
       convertedObjectValue[propertyArg.name] = validationResult.validValue as
-        | ArgumentValueType
-        | ArgumentValues
-        | Array<ArgumentValues>;
+        | ValueType
+        | Values
+        | Array<Values>;
     }
     // fast fail
     if (validationResult.invalidArgument !== undefined) {
@@ -365,14 +362,11 @@ function validateObjectValue(
 
 function doSubCommandArgumentValidation(
   argument: SubCommandArgument | ComplexOption,
-  value:
-    | PopulatedArgumentValueType
-    | PopulatedArgumentValues
-    | Array<PopulatedArgumentValues | undefined>,
+  value: PopulatedValueType | PopulatedValues | Array<PopulatedValues | undefined>,
   isArray: boolean,
   isOptional: boolean,
   invalidArguments: Array<InvalidArgument>,
-): PopulatedArgumentValueType | PopulatedArgumentValues | Array<PopulatedArgumentValues> {
+): PopulatedValueType | PopulatedValues | Array<PopulatedValues> {
   // if there is a value, check if it is valid
   if (value !== undefined) {
     let validationResult;
@@ -439,23 +433,20 @@ function doSubCommandArgumentValidation(
     }
     if (argument.validate && validationResult.validValue !== undefined) {
       const customError = argument.validate(
-        validationResult.validValue as ArgumentValueType | ArgumentValues | Array<ArgumentValues>,
+        validationResult.validValue as ValueType | Values | Array<Values>,
       );
       if (customError !== undefined) {
         invalidArguments.push({
           argument,
           name: argument.name,
-          value: validationResult.validValue as PopulatedArgumentValueType,
+          value: validationResult.validValue as PopulatedValueType,
           reason: InvalidArgumentReason.CUSTOM_VALIDATION,
           message: customError,
         });
         return undefined;
       }
     }
-    return validationResult.validValue as
-      | PopulatedArgumentValueType
-      | PopulatedArgumentValues
-      | undefined;
+    return validationResult.validValue as PopulatedValueType | PopulatedValues | undefined;
   }
 
   // if there is no value, check if it was optional
@@ -478,12 +469,9 @@ function doSubCommandArgumentValidation(
  */
 export function validateOptionValue(
   option: Option | ComplexOption,
-  value:
-    | PopulatedArgumentValueType
-    | PopulatedArgumentValues
-    | Array<PopulatedArgumentValues | undefined>,
+  value: PopulatedValueType | PopulatedValues | Array<PopulatedValues | undefined>,
   invalidArguments: Array<InvalidArgument>,
-): PopulatedArgumentValueType | PopulatedArgumentValues | Array<PopulatedArgumentValues> {
+): PopulatedValueType | PopulatedValues | Array<PopulatedValues> {
   return doSubCommandArgumentValidation(
     option,
     value,
@@ -502,16 +490,16 @@ export function validateOptionValue(
  */
 export function validatePositionalValue(
   positional: Positional,
-  value: PopulatedArgumentValueType,
+  value: PopulatedValueType,
   invalidArguments: Array<InvalidArgument>,
-): PopulatedArgumentValueType {
+): PopulatedValueType {
   return doSubCommandArgumentValidation(
     positional,
     value,
     positional.isVarargMultiple || false,
     positional.isVarargOptional || false,
     invalidArguments,
-  ) as PopulatedArgumentValueType;
+  ) as PopulatedValueType;
 }
 
 /**
@@ -524,9 +512,9 @@ export function validatePositionalValue(
  */
 export function validateGlobalCommandArgumentValue(
   globalCommand: GlobalCommand,
-  value: PopulatedArgumentSingleValueType,
+  value: PopulatedSingleValueType,
   invalidArguments: Array<InvalidArgument>,
-): PopulatedArgumentSingleValueType {
+): PopulatedSingleValueType {
   // if this function is called it is because the argument is defined
   const globalCommandArgument = globalCommand.argument!;
 
@@ -553,9 +541,7 @@ export function validateGlobalCommandArgumentValue(
     }
 
     if (globalCommandArgument.validate && validationResult.validValue !== undefined) {
-      const customError = globalCommandArgument.validate(
-        validationResult.validValue as ArgumentValueType,
-      );
+      const customError = globalCommandArgument.validate(validationResult.validValue as ValueType);
       if (customError !== undefined) {
         invalidArguments.push({
           argument: globalCommandArgument,
@@ -567,7 +553,7 @@ export function validateGlobalCommandArgumentValue(
         return undefined;
       }
     }
-    return validationResult.validValue as PopulatedArgumentSingleValueType;
+    return validationResult.validValue as PopulatedSingleValueType;
   }
 
   // if there is no value, check if it was optional

package/src/runtime/values/globalCommandValuePopulation.ts

@@ -1,23 +1,23 @@
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommandValuePopulationResult } from "./ValuePopulationResult.ts";
-import { ArgumentValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
-import type { PopulatedArgumentSingleValueType } from "@flowscripter/dynamic-cli-framework-api";
+import { ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
+import type { PopulatedSingleValueType } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.ts";
 import { InvalidArgumentReason } from "@flowscripter/dynamic-cli-framework-api";
 
 const logger = getLogger("globalCommandValuePopulation");
 
 /**
- * Attempt to populate a {@link ArgumentValueType} for the provided {@link GlobalCommand} using the provided potential args.
+ * Attempt to populate a {@link ValueType} for the provided {@link GlobalCommand} using the provided potential args.
  *
- * @param globalCommand the {@link GlobalCommand} for which {@link ArgumentValues} values should be populated.
+ * @param globalCommand the {@link GlobalCommand} for which {@link Values} values should be populated.
  * @param potentialArgs the potential args to use for population.
  * @param defaultValue optional default value to use for population before parsing the provided arguments.
  */
 export default function populateGlobalCommandValue(
   globalCommand: GlobalCommand,
   potentialArgs: ReadonlyArray<string>,
-  defaultValue: PopulatedArgumentSingleValueType,
+  defaultValue: PopulatedSingleValueType,
 ): GlobalCommandValuePopulationResult {
   logger.debug(() => {
     const message = `Populating value for global command: '${globalCommand.name}' using potential args: ${potentialArgs.join(
@@ -43,7 +43,7 @@ export default function populateGlobalCommandValue(
     const firstPotentialArg = potentialArgs[0];
 
     // don't use potentialArg if it cannot be a boolean value...
-    if (argument.type === ArgumentValueTypeName.BOOLEAN) {
+    if (argument.type === ValueTypeName.BOOLEAN) {
       const firstPotentialArgLower = firstPotentialArg!.toLowerCase();
 
       if (firstPotentialArgLower !== "true" && firstPotentialArgLower !== "false") {
@@ -59,7 +59,7 @@ 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 &&
+    argument.type === ValueTypeName.BOOLEAN &&
     (populatedArgumentValue === undefined || argument.defaultValue === false)
   ) {
     return {