@flowscripter/dynamic-cli-framework 1.7.2 → 1.7.4

package/dist/src/runtime/scanner.js

@@ -0,0 +1,244 @@
+import getLogger from "../util/logger.js";
+import { isGroupCommand } from "./command/CommandTypeGuards.js";
+const logger = getLogger("scanner");
+function normaliseFirstArgumentIfRequired(args, globalCommandsByName, globalCommandsByShortAlias) {
+    const firstArg = args[0];
+    // only looking for:
+    // --<global_[modifier_]command_name>
+    // --<global_[modifier_]command_name>=<value>
+    // -<global_[modifier_]command_short_alias>
+    // -<global_[modifier_]command_short_alias>=<value>
+    if (firstArg.length < 2 || firstArg.charAt(0) !== "-") {
+        return args;
+    }
+    // looking for:
+    // --<global_[modifier_]command_name>
+    // --<global_[modifier_]command_name>=<value>
+    if (firstArg.length > 2 && firstArg.charAt(1) === "-") {
+        let potentialGlobalCommandName = firstArg.slice(2);
+        // looking for:
+        // <global_command_name>=<value>
+        // <global_modifier_command_name>=<value>
+        let nextArg;
+        if (potentialGlobalCommandName.includes("=")) {
+            [potentialGlobalCommandName, nextArg] = potentialGlobalCommandName.split(/=(.*)/);
+        }
+        if (!globalCommandsByName.has(potentialGlobalCommandName)) {
+            // nothing changed
+            return args;
+        }
+        if (!nextArg) {
+            // nothing changed
+            return args;
+        }
+        logger.debug(() => `Normalised arg: '${firstArg}' to: '--${potentialGlobalCommandName} ${nextArg}'`);
+        return [`--${potentialGlobalCommandName}`, nextArg, ...args.slice(1)];
+    }
+    // looking for:
+    // -<global_[modifier_]command_short_alias>
+    // -<global_[modifier_]command_short_alias>=<value>
+    // (by now we know the arg starts with -<char>)
+    let potentialGlobalCommandShortAlias = firstArg.slice(1);
+    // looking for:
+    // <global_[modifier_]command_short_alias>=<value>
+    let nextArg;
+    if (potentialGlobalCommandShortAlias.includes("=")) {
+        [potentialGlobalCommandShortAlias, nextArg] = potentialGlobalCommandShortAlias.split(/=(.*)/);
+    }
+    if (!globalCommandsByShortAlias) {
+        // nothing changed
+        return args;
+    }
+    // looking for <global_[modifier_]command_short_alias>
+    const globalCommand = globalCommandsByShortAlias.get(potentialGlobalCommandShortAlias);
+    if (!globalCommand) {
+        // nothing changed
+        return args;
+    }
+    if (nextArg) {
+        logger.debug(() => `Normalised arg: '${firstArg}' to: '--${globalCommand.name} ${nextArg}'`);
+        return [`--${globalCommand.name}`, nextArg, ...args.slice(1)];
+    }
+    logger.debug(() => `Normalised arg: '${firstArg}' to: '--${globalCommand.name}'`);
+    return [`--${globalCommand.name}`, ...args.slice(1)];
+}
+function scanForNextCommandClause(potentialArgs, includeSubCommands, commandsByName, globalCommandsByShortAlias, groupAndMemberCommandsByJoinedName) {
+    let pendingArgs = [...potentialArgs];
+    const unusedArgs = [];
+    while (pendingArgs.length > 0) {
+        pendingArgs = normaliseFirstArgumentIfRequired(pendingArgs, commandsByName, globalCommandsByShortAlias);
+        // take first argument
+        const currentArg = pendingArgs[0];
+        pendingArgs = pendingArgs.slice(1);
+        // looking for:
+        // <global_[modifier_]command_name>
+        if (currentArg.startsWith("--")) {
+            const potentialCommandName = currentArg.slice(2);
+            // check for Global[Modifier]Command name
+            const command = commandsByName.get(potentialCommandName);
+            if (command) {
+                logger.debug("Found global [modifier] command name: %s", potentialCommandName);
+                return {
+                    commandClause: {
+                        command,
+                        potentialArgs: pendingArgs,
+                    },
+                    unusedArgs,
+                };
+            }
+        }
+        if (!includeSubCommands || currentArg[0] === "-") {
+            unusedArgs.push(currentArg);
+            continue;
+        }
+        if (groupAndMemberCommandsByJoinedName) {
+            // looking for:
+            // <group_command_name>:<member_sub_command_name>
+            // <group_command_name> <member_sub_command_name>
+            // <sub_command_name>
+            let potentialGroupCommandName = currentArg;
+            let potentialMemberSubCommandName;
+            let potentialMemberCommandNameArgumentUsed = false;
+            if (potentialGroupCommandName.includes(":")) {
+                // looking for:
+                // <group_command_name>:<member_sub_command_name>
+                [potentialGroupCommandName, potentialMemberSubCommandName] =
+                    potentialGroupCommandName.split(":");
+            }
+            else if (pendingArgs.length > 0) {
+                // looking for:
+                // <group_command_name> <member_sub_command_name>
+                potentialMemberSubCommandName = pendingArgs[0];
+                pendingArgs = pendingArgs.slice(1);
+                potentialMemberCommandNameArgumentUsed = true;
+            }
+            if (potentialMemberSubCommandName !== undefined) {
+                const result = groupAndMemberCommandsByJoinedName.get(`${potentialGroupCommandName}:${potentialMemberSubCommandName}`);
+                if (result && result.command) {
+                    const { groupCommand, command } = result;
+                    logger.debug("Found group command name: %s and member sub-command name: %s", potentialGroupCommandName, potentialMemberSubCommandName);
+                    return {
+                        commandClause: {
+                            command,
+                            groupCommand,
+                            potentialArgs: pendingArgs,
+                        },
+                        unusedArgs,
+                    };
+                }
+            }
+            // if group parsing was not needed, revert state if necessary
+            if (potentialMemberCommandNameArgumentUsed && potentialMemberSubCommandName !== undefined) {
+                pendingArgs.unshift(potentialMemberSubCommandName);
+            }
+        }
+        // looking for:
+        // <sub_command_name>
+        //
+        // if we find it is a group command we skip it as we didn't find a member command
+        // following it the logic above
+        const command = commandsByName.get(currentArg);
+        if (command && !isGroupCommand(command)) {
+            logger.debug("Found sub-command name: %s", currentArg);
+            return {
+                commandClause: {
+                    command,
+                    potentialArgs: pendingArgs,
+                },
+                unusedArgs,
+            };
+        }
+        // if we got here we haven't found a command so add the current arg to unused args
+        unusedArgs.push(currentArg);
+    }
+    // if we got here we haven't found a command and we have processed all provided args
+    return {
+        commandClause: undefined,
+        unusedArgs,
+    };
+}
+/**
+ * Scan the provided arguments and return any {@link CommandClause} instances discovered based on the provided
+ * list of {@link GlobalModifierCommand} instances.
+ *
+ * @param argSequences the list of argument sequences to scan.
+ * @param globalModifierCommandsByName the map of {@link GlobalModifierCommand} instances by name to use when scanning.
+ * @param globalModifierCommandsByShortAlias the map of {@link GlobalModifierCommand} instances by short alias to use when scanning.
+ */
+export function scanForGlobalModifierCommandClauses(argSequences, globalModifierCommandsByName, globalModifierCommandsByShortAlias) {
+    logger.debug(() => `Scanning args: '${JSON.stringify(argSequences)}' for global modifier commands: '${Array.from(globalModifierCommandsByName.keys()).join(" ")}'`);
+    const scanResult = {
+        unusedArgSequences: [],
+    };
+    const commandClauses = [];
+    for (const argSequence of argSequences) {
+        let lastCommandClause;
+        let args = argSequence;
+        while (args.length > 0) {
+            const { commandClause, unusedArgs } = scanForNextCommandClause(args, false, globalModifierCommandsByName, globalModifierCommandsByShortAlias, undefined);
+            // any args that weren't used in the current scan are...
+            if (unusedArgs.length > 0) {
+                if (lastCommandClause) {
+                    // ... given back to the previous scan result if defined
+                    lastCommandClause.potentialArgs = unusedArgs;
+                }
+                else {
+                    // ... or added to the unused arg sequences
+                    scanResult.unusedArgSequences.push(unusedArgs);
+                }
+            }
+            // if we didn't find a command clause all args have been allocated to
+            // a previous clause or the unuused arg sequences, so we can stop scanning
+            if (!commandClause) {
+                break;
+            }
+            // save the command we found
+            commandClauses.push(commandClause);
+            // now set the current scan result as the last scan result
+            lastCommandClause = commandClause;
+            // temporarily take all of the potential args from the last command clause and use them for a potential
+            // new command clause, if any args are left over they will be added back to the last command clause
+            args = lastCommandClause.potentialArgs;
+            lastCommandClause.potentialArgs = [];
+        }
+    }
+    if (commandClauses.length > 0) {
+        scanResult.globalModifierCommandClauses = commandClauses;
+    }
+    logger.debug("scan result: %O", scanResult);
+    return scanResult;
+}
+/**
+ * Scan the provided arguments and return the first {@link CommandClause} instance discovered based on the provided
+ * list of non-modifier {@link Command} instances.
+ *
+ * @param argSequences the list of argument sequences to scan.
+ * @param nonModifierCommandsByName the map of non-modifier {@link Command} instances by name to use when scanning.
+ * @param globalCommandsByShortAlias optional map of {@link GlobalCommand} instances by short alias to use when scanning.
+ * @param groupAndMemberCommandsByJoinedName optional map of {@link GroupCommand} and member {@link SubCommand} instances to use when scanning.
+ */
+export function scanForNonModifierCommandClause(argSequences, nonModifierCommandsByName, globalCommandsByShortAlias, groupAndMemberCommandsByJoinedName) {
+    logger.debug(() => `Scanning args: '${JSON.stringify(argSequences)}' for non-modifier commands: '${Array.from(nonModifierCommandsByName.keys()).join(" ")}'`);
+    const scanResult = {
+        unusedArgSequences: [],
+    };
+    for (const argSequence of argSequences) {
+        // if a command clause is already defined, we don't need to scan any further,
+        // just add the unused args to the unused arg sequences
+        if (scanResult.nonModifierCommandClause) {
+            scanResult.unusedArgSequences.push(argSequence);
+            continue;
+        }
+        const { commandClause, unusedArgs } = scanForNextCommandClause(argSequence, true, nonModifierCommandsByName, globalCommandsByShortAlias, groupAndMemberCommandsByJoinedName);
+        // args that weren't used in the current scan are given to the unused arg sequences
+        if (unusedArgs.length > 0) {
+            scanResult.unusedArgSequences.push(unusedArgs);
+        }
+        // use the result if we found a command
+        if (commandClause) {
+            scanResult.nonModifierCommandClause = commandClause;
+        }
+    }
+    logger.debug("scan result: %O", scanResult);
+    return scanResult;
+}

package/dist/src/runtime/values/argumentValueMerge.js

@@ -0,0 +1,122 @@
+import { MAXIMUM_ARGUMENT_ARRAY_SIZE } from "../../api/argument/SubCommandArgument.js";
+import { MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH } from "../../api/argument/ComplexOption.js";
+function doClone(source, nestingLevel) {
+    if (source === undefined) {
+        return source;
+    }
+    // check if source is an array
+    if (Array.isArray(source)) {
+        return arrayMerge(source, [], nestingLevel);
+    }
+    // check if source is an object
+    if (typeof source === "object") {
+        return objectMerge(source, {}, nestingLevel);
+    }
+    // source must be a primitive value
+    return source;
+}
+function arrayMerge(override, base, nestingLevel) {
+    if (override.length > MAXIMUM_ARGUMENT_ARRAY_SIZE) {
+        throw new Error(`Maximum array size exceeded: ${override.length}`);
+    }
+    if (base.length > MAXIMUM_ARGUMENT_ARRAY_SIZE) {
+        throw new Error(`Maximum array size exceeded: ${override.length}`);
+    }
+    const result = base.slice();
+    override.forEach((argValue, index) => {
+        if (Array.isArray(argValue)) {
+            throw new Error(`Array of array values discovered, this is not supported: ${JSON.stringify(argValue)}`);
+        }
+        if (index >= base.length) {
+            result.push(doClone(argValue, nestingLevel));
+        }
+        else {
+            result[index] = doMerge(argValue, base[index], nestingLevel);
+        }
+    });
+    return result;
+}
+function objectMerge(override, base, nestingLevel) {
+    if (nestingLevel > MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH) {
+        throw new Error(`Maximum complex option nesting depth exceeded: ${nestingLevel}`);
+    }
+    nestingLevel++;
+    const result = {};
+    Object.keys(override).forEach((argName) => {
+        if (base[argName] === undefined) {
+            // nothing to merge so just clone the override
+            result[argName] = doClone(override[argName], nestingLevel);
+        }
+        else {
+            // merge the base and the override
+            result[argName] = doMerge(override[argName], base[argName], nestingLevel);
+        }
+    });
+    Object.keys(base).forEach((argName) => {
+        // if the base is in the override, we have already merged above
+        if (override[argName] !== undefined) {
+            return;
+        }
+        // nothing to merge so just clone the base
+        result[argName] = doClone(base[argName], nestingLevel);
+    });
+    return result;
+}
+function doMerge(override, defaults, nestingLevel) {
+    if (defaults === undefined) {
+        throw new Error(`Undefined value provided in merge: override = ${JSON.stringify(override)}, defaults = undefined`);
+    }
+    if (typeof override !== typeof defaults) {
+        // check if we need to convert from single value to array
+        if (Array.isArray(override)) {
+            if (typeof defaults === "object") {
+                defaults = [defaults];
+            }
+            else {
+                defaults = [defaults];
+            }
+        }
+        else if (Array.isArray(defaults)) {
+            if (typeof override === "object") {
+                override = [override];
+            }
+            else {
+                override = [override];
+            }
+        } // 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")) {
+            defaults = `${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)}`);
+    }
+    // check if override is an array
+    if (Array.isArray(override)) {
+        return arrayMerge(override, defaults, nestingLevel);
+    }
+    // check if override is an object
+    if (typeof override === "object") {
+        return objectMerge(override, defaults, nestingLevel);
+    }
+    // check if override is undefined so we should use default
+    if (override === undefined) {
+        return doClone(defaults, nestingLevel);
+    }
+    // override must be a primitive value
+    return override;
+}
+/**
+ * Deep merge of provided default argument values with overridden argument values. The result is a cloned instance
+ * of `defaults` with values in `override` cloned and merged in the result.
+ *
+ * @throws {Error} if a value appears under the same argument name in both `override` and `defaults`.
+ * and they are not of the same type, or if either argument is `undefined`.
+ *
+ * @param override the values which should be used in place of any defined in `defaults`.
+ * @param defaults the values to use unless they are overridden in `override`.
+ */
+export default function argumentValueMerge(override, defaults) {
+    return doMerge(override, defaults, 0);
+}