@yamato-daiwa/es-extensions-nodejs 0.0.2 → 0.10.0-alpha.0

package/Distributable/ConsoleCommandsParser/ConsoleCommandsParser.js

@@ -0,0 +1,702 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const json5_1 = __importDefault(require("json5"));
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+const InvalidConsoleCommandError_1 = __importDefault(require("../Errors/InvalidConsoleCommand/InvalidConsoleCommandError"));
+const ConsoleCommandsParserLocalization_english_1 = __importDefault(require("./ConsoleCommandsParserLocalization.english"));
+class ConsoleCommandsParser {
+    static localization = ConsoleCommandsParserLocalization_english_1.default;
+    static MINIMAL_ARGUMENTS_COUNT_IN_VALID_CONSOLE_COMMAND = 2;
+    static PARSING_METHOD_INVOCATION_EXPRESSION = "ConsoleCommandsParser.parse(commandLineInterfaceSpecification, argumentsVector)";
+    applicationName;
+    targetCommandPhrase;
+    targetCommandPhraseDescription;
+    isTargetCommandPhraseDefault;
+    targetCommandOptions;
+    targetCommandOptionsWhichHasNotBeenProcessedYet = [];
+    targetCommandOptionsSpecification;
+    static parse(commandLineInterfaceSpecification, argumentsVector = process.argv) {
+        ConsoleCommandsParser.validateCommandLineInterfaceSpecification(commandLineInterfaceSpecification);
+        if (!Array.isArray(argumentsVector)) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: commandLineInterfaceSpecification.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.argumentsVectorIsNotArray.
+                        generate({ stringifiedActualValueOfArgumentsVector: (0, es_extensions_1.stringifyAndFormatArbitraryValue)(argumentsVector) })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        if (argumentsVector.length < ConsoleCommandsParser.MINIMAL_ARGUMENTS_COUNT_IN_VALID_CONSOLE_COMMAND) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: commandLineInterfaceSpecification.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                        argumentsVectorHasNotEnoughElements.generate({
+                        minimalElementsCountInArgumentsVector: ConsoleCommandsParser.MINIMAL_ARGUMENTS_COUNT_IN_VALID_CONSOLE_COMMAND,
+                        actualElementsCountInArgumentsVector: argumentsVector.length,
+                        stringifiedArgumentsVector: (0, es_extensions_1.stringifyAndFormatArbitraryValue)(argumentsVector)
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        const consciouslyInputtedArguments = [];
+        const nonStringArguments = [];
+        let NodeJS_InterpreterAbsolutePath = "";
+        let executableFileAbsolutePath = "";
+        for (const [index, argument] of argumentsVector.entries()) {
+            if (!(0, es_extensions_1.isString)(argument)) {
+                nonStringArguments.push(argument);
+                continue;
+            }
+            switch (index) {
+                case 0: {
+                    NodeJS_InterpreterAbsolutePath = argument;
+                    break;
+                }
+                case 1: {
+                    executableFileAbsolutePath = argument;
+                    break;
+                }
+                default: {
+                    consciouslyInputtedArguments.push(argument);
+                }
+            }
+        }
+        if (nonStringArguments.length > 0) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: commandLineInterfaceSpecification.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                        argumentsVectorHasNonStringElements.generate({
+                        stringifiedFormattedNonStringArguments: (0, es_extensions_1.stringifyAndFormatArbitraryValue)(nonStringArguments)
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        const dataHoldingSelfInstance = new ConsoleCommandsParser({
+            commandLineInterfaceSpecification, consciouslyInputtedArguments
+        });
+        return {
+            NodeJS_InterpreterAbsolutePath,
+            executableFileAbsolutePath,
+            phrase: dataHoldingSelfInstance.targetCommandPhrase,
+            ...dataHoldingSelfInstance.parseOptionsAndParameters()
+        };
+    }
+    static generateFullHelpReference(commandLineInterfaceSpecification) {
+        ConsoleCommandsParser.validateCommandLineInterfaceSpecification(commandLineInterfaceSpecification);
+        const textSegments = [];
+        if ((0, es_extensions_1.isNonEmptyString)(commandLineInterfaceSpecification.applicationDescription)) {
+            textSegments.push(commandLineInterfaceSpecification.applicationDescription);
+        }
+        const commandPhrasesReferences = [];
+        for (const [commandPhrase, commandPhraseSpecification] of Object.entries(commandLineInterfaceSpecification.commandPhrases)) {
+            commandPhrasesReferences.push(this.generateSingleCommandPhraseHelpReference({
+                commandPhrase,
+                commandPhraseSpecification: { ...commandPhraseSpecification, isDefault: commandPhraseSpecification.isDefault === true }
+            }));
+        }
+        textSegments.push("\n\n", commandPhrasesReferences.join("\n\n"));
+        return textSegments.join("");
+    }
+    constructor({ commandLineInterfaceSpecification, consciouslyInputtedArguments }) {
+        const helpReference = ConsoleCommandsParser.generateFullHelpReference(commandLineInterfaceSpecification);
+        const firstConsciouslyInputtedArgument = consciouslyInputtedArguments[0];
+        let defaultCommandPhrase;
+        for (const [commandPhrase, commandPhraseSpecification] of Object.entries(commandLineInterfaceSpecification.commandPhrases)) {
+            if (commandPhraseSpecification.isDefault === true) {
+                defaultCommandPhrase = { name: commandPhrase, specification: commandPhraseSpecification };
+                break;
+            }
+        }
+        let targetCommandPhrase;
+        let targetCommandPhraseDescription;
+        let targetCommandOptions;
+        let optionsSpecificationForRecognizedCommandPhrase;
+        if ((0, es_extensions_1.isUndefined)(firstConsciouslyInputtedArgument)) {
+            if ((0, es_extensions_1.isUndefined)(defaultCommandPhrase)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                            noDefaultCommandPhraseAvailable.generate({ helpReference })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                    occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+                });
+            }
+            targetCommandPhrase = defaultCommandPhrase.name;
+            targetCommandPhraseDescription = defaultCommandPhrase.specification.description;
+            optionsSpecificationForRecognizedCommandPhrase = defaultCommandPhrase.specification.options ?? {};
+        }
+        else if (ConsoleCommandsParser.isCommandArgumentTheOption(firstConsciouslyInputtedArgument)) {
+            if ((0, es_extensions_1.isUndefined)(defaultCommandPhrase)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                            noDefaultCommandPhraseAvailable.generate({ helpReference })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                    occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+                });
+            }
+            targetCommandPhrase = defaultCommandPhrase.name;
+            targetCommandPhraseDescription = defaultCommandPhrase.specification.description;
+            optionsSpecificationForRecognizedCommandPhrase = defaultCommandPhrase.specification.options ?? {};
+            targetCommandOptions = [...consciouslyInputtedArguments];
+        }
+        else {
+            if ((0, es_extensions_1.isUndefined)(commandLineInterfaceSpecification.commandPhrases)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                            firstParameterLooksLikeCommandPhraseWhileNoCommandPhrasesAvailable.generate({
+                            commandPhraseLikeArgument: firstConsciouslyInputtedArgument, helpReference
+                        })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                    occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+                });
+            }
+            targetCommandPhrase = firstConsciouslyInputtedArgument;
+            targetCommandOptions = consciouslyInputtedArguments.slice(1);
+            for (const [commandPhrase, commandPhraseSpecification] of Object.entries(commandLineInterfaceSpecification.commandPhrases)) {
+                if (commandPhrase === targetCommandPhrase) {
+                    targetCommandPhraseDescription = commandPhraseSpecification.description;
+                    optionsSpecificationForRecognizedCommandPhrase = commandPhraseSpecification.options ?? {};
+                    break;
+                }
+            }
+            if ((0, es_extensions_1.isUndefined)(optionsSpecificationForRecognizedCommandPhrase)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.unknownCommandPhrase.generate({
+                            inputtedCommandPhrase: targetCommandPhrase, helpReference
+                        })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                    occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+                });
+            }
+        }
+        this.applicationName = commandLineInterfaceSpecification.applicationName;
+        this.targetCommandPhrase = targetCommandPhrase;
+        this.targetCommandPhraseDescription = targetCommandPhraseDescription;
+        this.isTargetCommandPhraseDefault = this.targetCommandPhrase === defaultCommandPhrase?.name;
+        this.targetCommandOptions = targetCommandOptions;
+        this.targetCommandOptionsSpecification = optionsSpecificationForRecognizedCommandPhrase;
+    }
+    parseOptionsAndParameters() {
+        if ((0, es_extensions_1.isUndefined)(this.targetCommandOptionsSpecification)) {
+            return {};
+        }
+        const parsedOptions = {};
+        this.targetCommandOptionsWhichHasNotBeenProcessedYet.push(...this.targetCommandOptions ?? []);
+        for (const [optionKey, optionSpecification] of Object.entries(this.targetCommandOptionsSpecification)) {
+            const optionKeyWithoutLeading2NDashes = optionKey.startsWith("--") ? optionKey.slice(2) : optionKey;
+            const optionKeyWithLeading2NDashes = `--${optionKeyWithoutLeading2NDashes}`;
+            const optionName = optionSpecification.newName ?? optionKeyWithoutLeading2NDashes;
+            let shortcutWithLeadingNDash;
+            if ((0, es_extensions_1.isNotUndefined)(optionSpecification.shortcut)) {
+                shortcutWithLeadingNDash = optionSpecification.shortcut.startsWith("-") ?
+                    optionSpecification.shortcut : `-${optionSpecification.shortcut}`;
+            }
+            const arrayIndexOfCurrentOptionKey = this.targetCommandOptionsWhichHasNotBeenProcessedYet.findIndex((commandOption) => commandOption === optionKeyWithLeading2NDashes || commandOption === shortcutWithLeadingNDash);
+            const hasCurrentOptionBeenSpecified = arrayIndexOfCurrentOptionKey !== -1;
+            if (optionSpecification.type === ConsoleCommandsParser.ParametersTypes.boolean) {
+                if (hasCurrentOptionBeenSpecified) {
+                    this.targetCommandOptionsWhichHasNotBeenProcessedYet.splice(arrayIndexOfCurrentOptionKey, 1);
+                }
+                parsedOptions[optionName] = hasCurrentOptionBeenSpecified;
+                continue;
+            }
+            if (!hasCurrentOptionBeenSpecified) {
+                if ("defaultValue" in optionSpecification) {
+                    parsedOptions[optionName] = optionSpecification.defaultValue;
+                    continue;
+                }
+                if ("required" in optionSpecification && optionSpecification.required) {
+                    es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                        errorInstance: new InvalidConsoleCommandError_1.default({
+                            applicationName: this.applicationName,
+                            messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.requiredOptionKeyIsMissing.generate({
+                                commandPhrase: this.targetCommandPhrase,
+                                isDefaultCommandPhrase: this.isTargetCommandPhraseDefault,
+                                missingOptionKey: optionKeyWithLeading2NDashes,
+                                commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                                    commandPhrase: this.targetCommandPhrase,
+                                    commandPhraseSpecification: {
+                                        isDefault: this.isTargetCommandPhraseDefault,
+                                        description: this.targetCommandPhraseDescription,
+                                        options: this.targetCommandOptionsSpecification
+                                    }
+                                })
+                            })
+                        }),
+                        title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                        occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+                    });
+                }
+                continue;
+            }
+            const potentialValueOfCurrentOption = this.targetCommandOptionsWhichHasNotBeenProcessedYet[arrayIndexOfCurrentOptionKey + 1];
+            if ((0, es_extensions_1.isUndefined)(potentialValueOfCurrentOption)) {
+                es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: this.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                            noValueFollowingTheKeyOfNonBooleanOption.generate({
+                            targetOptionKey: optionKeyWithLeading2NDashes,
+                            commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                                commandPhrase: this.targetCommandPhrase,
+                                commandPhraseSpecification: {
+                                    isDefault: this.isTargetCommandPhraseDefault,
+                                    description: this.targetCommandPhraseDescription,
+                                    options: this.targetCommandOptionsSpecification
+                                }
+                            })
+                        })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                    occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+                });
+            }
+            switch (optionSpecification.type) {
+                case ConsoleCommandsParser.ParametersTypes.string: {
+                    parsedOptions[optionName] = this.processStringTypeOptionValue({
+                        targetOptionRawValue: potentialValueOfCurrentOption,
+                        optionKeyWithLeading2NDashes,
+                        optionSpecification
+                    });
+                    break;
+                }
+                case ConsoleCommandsParser.ParametersTypes.number: {
+                    parsedOptions[optionName] = this.processNumberTypeOptionValue({
+                        targetOptionRawValue: potentialValueOfCurrentOption,
+                        optionKeyWithLeading2NDashes,
+                        optionSpecification
+                    });
+                    break;
+                }
+                case ConsoleCommandsParser.ParametersTypes.JSON5: {
+                    const targetParsedJSON5_ParameterValue = this.
+                        extractAndValidateParsedJSON5_ParameterValue({
+                        targetOptionRawValue: potentialValueOfCurrentOption,
+                        optionKeyWithLeading2NDashes,
+                        optionSpecification
+                    });
+                    if ((0, es_extensions_1.isNotUndefined)(targetParsedJSON5_ParameterValue)) {
+                        parsedOptions[optionName] = targetParsedJSON5_ParameterValue;
+                    }
+                    break;
+                }
+                default: {
+                    es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                        errorType: "InvalidConsoleCommandOptionSpecification",
+                        title: "Invalid console command option specification",
+                        description: ConsoleCommandsParser.localization.errorsMessages.invalidCommandOptionTypeAtSpecification.generate({
+                            optionName, typeName: String(optionSpecification.type)
+                        }),
+                        occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+                    });
+                }
+            }
+            this.targetCommandOptionsWhichHasNotBeenProcessedYet.splice(arrayIndexOfCurrentOptionKey, 2);
+        }
+        if (this.targetCommandOptionsWhichHasNotBeenProcessedYet.length > 0) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.unknownOptionsFoundForSpecificCommand.generate({
+                        commandPhrase: this.targetCommandPhrase,
+                        formattedUnknownOptions: (0, es_extensions_1.stringifyAndFormatArbitraryValue)(this.targetCommandOptionsWhichHasNotBeenProcessedYet),
+                        commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandPhraseSpecification: {
+                                isDefault: this.isTargetCommandPhraseDefault,
+                                description: this.targetCommandPhraseDescription,
+                                options: this.targetCommandOptionsSpecification
+                            }
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        return parsedOptions;
+    }
+    processStringTypeOptionValue({ targetOptionRawValue, optionKeyWithLeading2NDashes, optionSpecification }) {
+        const { allowedAlternatives } = optionSpecification;
+        if ((0, es_extensions_1.isNonEmptyArray)(allowedAlternatives) && !allowedAlternatives.includes(targetOptionRawValue)) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                        optionValueIsNotAmongAllowedAlternatives.generate({
+                        targetOptionKey: optionKeyWithLeading2NDashes,
+                        actualOptionValue: targetOptionRawValue,
+                        commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandPhraseSpecification: {
+                                isDefault: this.isTargetCommandPhraseDefault,
+                                description: this.targetCommandPhraseDescription,
+                                options: this.targetCommandOptionsSpecification
+                            }
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        return targetOptionRawValue;
+    }
+    processNumberTypeOptionValue({ targetOptionRawValue, optionKeyWithLeading2NDashes, optionSpecification }) {
+        const { numbersSet, minimalValue, maximalValue } = optionSpecification;
+        const targetOptionParsedValue = Number(targetOptionRawValue);
+        if (Number.isNaN(targetOptionParsedValue)) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.unparsableNumericOptionValue.generate({
+                        targetOptionKey: optionKeyWithLeading2NDashes,
+                        actualOptionValue: targetOptionRawValue,
+                        commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandPhraseSpecification: {
+                                isDefault: this.isTargetCommandPhraseDefault,
+                                description: this.targetCommandPhraseDescription,
+                                options: this.targetCommandOptionsSpecification
+                            }
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        let isOptionValueMatchingWithExpectedNumberSet;
+        switch (numbersSet) {
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.naturalNumber: {
+                isOptionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNaturalNumber)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.naturalNumberOrZero:
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.positiveIntegerOrZero: {
+                isOptionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNaturalNumberOrZero)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeInteger: {
+                isOptionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNegativeInteger)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeIntegerOrZero: {
+                isOptionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNegativeIntegerOrZero)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.anyInteger: {
+                isOptionValueMatchingWithExpectedNumberSet = Number.isInteger(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.positiveDecimalFraction: {
+                isOptionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isPositiveDecimalFraction)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.positiveDecimalFractionOrZero: {
+                isOptionValueMatchingWithExpectedNumberSet =
+                    (0, es_extensions_1.isPositiveDecimalFraction)(targetOptionParsedValue) || targetOptionParsedValue === 0;
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeDecimalFraction: {
+                isOptionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNegativeDecimalFraction)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeDecimalFractionOrZero: {
+                isOptionValueMatchingWithExpectedNumberSet =
+                    (0, es_extensions_1.isNegativeDecimalFraction)(targetOptionParsedValue) || targetOptionParsedValue === 0;
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.anyDecimalFraction: {
+                isOptionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isDecimalFractionOfAnySign)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.anyDecimalFractionOrZero: {
+                isOptionValueMatchingWithExpectedNumberSet =
+                    (0, es_extensions_1.isDecimalFractionOfAnySign)(targetOptionParsedValue) || targetOptionParsedValue === 0;
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.anyRealNumber: {
+                isOptionValueMatchingWithExpectedNumberSet = true;
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.positiveRealNumber: {
+                isOptionValueMatchingWithExpectedNumberSet = targetOptionParsedValue > 0;
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeRealNumber: {
+                isOptionValueMatchingWithExpectedNumberSet = targetOptionParsedValue < 0;
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.positiveRealNumberOrZero: {
+                isOptionValueMatchingWithExpectedNumberSet = targetOptionParsedValue >= 0;
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeRealNumberOrZero: {
+                isOptionValueMatchingWithExpectedNumberSet = targetOptionParsedValue <= 0;
+            }
+        }
+        if (!isOptionValueMatchingWithExpectedNumberSet) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                        numericOptionValueIsNotBelongToExpectedNumbersSet.generate({
+                        targetOptionKey: optionKeyWithLeading2NDashes,
+                        expectedNumbersSet: numbersSet,
+                        actualOptionValue: targetOptionRawValue,
+                        commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandPhraseSpecification: {
+                                isDefault: this.isTargetCommandPhraseDefault,
+                                description: this.targetCommandPhraseDescription,
+                                options: this.targetCommandOptionsSpecification
+                            }
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        if ((0, es_extensions_1.isNotUndefined)(minimalValue) && targetOptionParsedValue <= minimalValue) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                        numericValueIsSmallerThanRequiredMinimum.generate({
+                        targetOptionKey: optionKeyWithLeading2NDashes,
+                        requiredMinimum: minimalValue,
+                        actualOptionValue: targetOptionRawValue,
+                        commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandPhraseSpecification: {
+                                isDefault: this.isTargetCommandPhraseDefault,
+                                description: this.targetCommandPhraseDescription,
+                                options: this.targetCommandOptionsSpecification
+                            }
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        if ((0, es_extensions_1.isNotUndefined)(maximalValue) && targetOptionParsedValue >= maximalValue) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.
+                        numericValueIsGreaterThanAllowedMaximum.generate({
+                        targetOptionKey: optionKeyWithLeading2NDashes,
+                        allowedMaximum: maximalValue,
+                        actualOptionValue: targetOptionRawValue,
+                        commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandPhraseSpecification: {
+                                isDefault: this.isTargetCommandPhraseDefault,
+                                description: this.targetCommandPhraseDescription,
+                                options: this.targetCommandOptionsSpecification
+                            }
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        return targetOptionParsedValue;
+    }
+    extractAndValidateParsedJSON5_ParameterValue({ targetOptionRawValue, optionKeyWithLeading2NDashes, optionSpecification }) {
+        let targetParameterParsedValue;
+        try {
+            targetParameterParsedValue = json5_1.default.parse(targetOptionRawValue);
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.errorsMessages.malformedJSON5_Option.generate({
+                        targetOptionKey: optionKeyWithLeading2NDashes,
+                        commandHelpReference: ConsoleCommandsParser.generateSingleCommandPhraseHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandPhraseSpecification: {
+                                isDefault: this.isTargetCommandPhraseDefault,
+                                description: this.targetCommandPhraseDescription,
+                                options: this.targetCommandOptionsSpecification
+                            }
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION,
+                innerError: error
+            });
+        }
+        const validationResult = es_extensions_1.RawObjectDataProcessor.
+            process(targetParameterParsedValue, {
+            nameForLogging: optionKeyWithLeading2NDashes,
+            subtype: es_extensions_1.RawObjectDataProcessor.ObjectSubtypes.fixedSchema,
+            properties: optionSpecification.validValueSpecification
+        });
+        if (validationResult.isRawDataInvalid) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorInstance: new es_extensions_1.InvalidExternalDataError({
+                    customMessage: ConsoleCommandsParser.localization.errorsMessages.JSON5_OptionDoesNotMatchWithValidDataSchema.generate({
+                        targetOptionKey: optionKeyWithLeading2NDashes,
+                        formattedValidationErrorsMessages: es_extensions_1.RawObjectDataProcessor.
+                            formatValidationErrorsList(validationResult.validationErrorsMessages)
+                    })
+                }),
+                title: es_extensions_1.InvalidExternalDataError.localization.defaultTitle,
+                occurrenceLocation: ConsoleCommandsParser.PARSING_METHOD_INVOCATION_EXPRESSION
+            });
+        }
+        return validationResult.processedData;
+    }
+    static isCommandArgumentTheOption(consoleCommandArgument) {
+        return consoleCommandArgument.startsWith("-");
+    }
+    static generateSingleCommandPhraseHelpReference({ commandPhrase, commandPhraseSpecification }) {
+        const indentationCoordinator = new es_extensions_1.IndentationCoordinator();
+        const textSegments = [
+            `● ${commandPhrase}${(0, es_extensions_1.insertSubstring)(ConsoleCommandsParser.localization.helpReference.defaultCommandPhrase__parenthetical, {
+                condition: commandPhraseSpecification.isDefault,
+                modifier: (defaultCommandPhrase__parenthetical) => ` ${defaultCommandPhrase__parenthetical}`
+            })}\n`
+        ];
+        if ((0, es_extensions_1.isNonEmptyString)(commandPhraseSpecification.description)) {
+            textSegments.push(indentationCoordinator.insertIncrementedIndentWithoutUpdatingOfIndentationMultiplier() +
+                commandPhraseSpecification.description);
+        }
+        const commandOptions = commandPhraseSpecification.options ?? {};
+        if (Object.entries(commandOptions).length > 0) {
+            indentationCoordinator.incrementIndent();
+            textSegments.push(`\n\n${indentationCoordinator.insertIndent()}` +
+                `■ ${ConsoleCommandsParser.localization.helpReference.options}`);
+            indentationCoordinator.incrementIndent();
+            for (const [commandOptionKey, commandOptionSpecification] of Object.entries(commandOptions)) {
+                textSegments.push(ConsoleCommandsParser.generateSingleCommandOptionHelpReference({
+                    commandOptionKey,
+                    commandOptionSpecification,
+                    indentationCoordinator
+                }));
+            }
+            indentationCoordinator.decrementIndent();
+        }
+        return textSegments.join("");
+    }
+    static generateSingleCommandOptionHelpReference({ commandOptionKey, commandOptionSpecification, indentationCoordinator }) {
+        const textSegments = [
+            `\n\n${indentationCoordinator.insertIndent()}--${commandOptionKey}` +
+                `\n${indentationCoordinator.incrementIndentAndInsert()}`
+        ];
+        const helpReferenceLocalization = ConsoleCommandsParser.localization.helpReference;
+        if ((0, es_extensions_1.isNonEmptyString)(commandOptionSpecification.description)) {
+            textSegments.push(`${commandOptionSpecification.description}\n`);
+        }
+        if ((0, es_extensions_1.isNotUndefined)(commandOptionSpecification.shortcut)) {
+            textSegments.push(`\n${indentationCoordinator.insertIndent()}` +
+                `◯ ${helpReferenceLocalization.shortcut}: -${commandOptionSpecification.shortcut}`);
+        }
+        textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ${helpReferenceLocalization.type}: ${commandOptionSpecification.type}`);
+        if ("required" in commandOptionSpecification) {
+            textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ${helpReferenceLocalization.isRequired}: ` +
+                (commandOptionSpecification.required ? helpReferenceLocalization.yes : helpReferenceLocalization.no));
+        }
+        else if ("defaultValue" in commandOptionSpecification) {
+            textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ${helpReferenceLocalization.defaultValue}: ` +
+                (0, es_extensions_1.stringifyAndFormatArbitraryValue)(commandOptionSpecification.defaultValue));
+        }
+        switch (commandOptionSpecification.type) {
+            case ConsoleCommandsParser.ParametersTypes.string: {
+                if ((0, es_extensions_1.isNonEmptyArray)(commandOptionSpecification.allowedAlternatives)) {
+                    textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ${helpReferenceLocalization.allowedAlternatives}:`);
+                    indentationCoordinator.incrementIndent();
+                    textSegments.push(commandOptionSpecification.allowedAlternatives.
+                        map((allowedAlternative) => `\n${indentationCoordinator.insertIndent()}◆ ${allowedAlternative}`).
+                        join(""));
+                    indentationCoordinator.decrementIndent();
+                }
+                break;
+            }
+            case ConsoleCommandsParser.ParametersTypes.number: {
+                textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ` +
+                    `${helpReferenceLocalization.numbersSet.key}: ` +
+                    `${helpReferenceLocalization.numbersSet.generateValue(commandOptionSpecification.numbersSet)} `);
+                if ((0, es_extensions_1.isNotUndefined)(commandOptionSpecification.minimalValue)) {
+                    textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ` +
+                        `${helpReferenceLocalization.minimalValue}: ${commandOptionSpecification.minimalValue}`);
+                }
+                if ((0, es_extensions_1.isNotUndefined)(commandOptionSpecification.maximalValue)) {
+                    textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ` +
+                        `${helpReferenceLocalization.maximalValue}: ${commandOptionSpecification.maximalValue}`);
+                }
+                break;
+            }
+            case ConsoleCommandsParser.ParametersTypes.JSON5: {
+                textSegments.push(`\n${indentationCoordinator.insertIndent()}◯ ` +
+                    `${helpReferenceLocalization.objectTypeValuePropertiesSpecification}:\n`);
+                indentationCoordinator.incrementIndent();
+                textSegments.push(indentationCoordinator.addCurrentIndentationToEachLineOf((0, es_extensions_1.stringifyAndFormatArbitraryValue)(commandOptionSpecification.validValueSpecification.properties)));
+                indentationCoordinator.decrementIndent();
+            }
+        }
+        indentationCoordinator.decrementIndent();
+        return textSegments.join("");
+    }
+    static validateCommandLineInterfaceSpecification(commandLineInterfaceSpecification) {
+        const specificationsOfCommandsMarkedAsDefault = Object.entries(commandLineInterfaceSpecification.commandPhrases).
+            reduce((_specificationsOfCommandsMarkedAsDefault, [commandPhrase, commandPhraseSpecification]) => {
+            if (commandPhraseSpecification.isDefault === true) {
+                _specificationsOfCommandsMarkedAsDefault[commandPhrase] = commandPhraseSpecification;
+            }
+            return _specificationsOfCommandsMarkedAsDefault;
+        }, {});
+        if (Object.entries(specificationsOfCommandsMarkedAsDefault).length > 1) {
+            es_extensions_1.Logger.throwErrorWithFormattedMessage({
+                errorType: "InvalidConsoleCommandSpecification",
+                title: "Invalid console command specification",
+                description: ConsoleCommandsParser.localization.errorsMessages.moreThanOneCommandPhrasesMarkedAsDefault.generate({
+                    formattedListOfCommandsPhrasesMarkedAsDefault: Object.
+                        keys(specificationsOfCommandsMarkedAsDefault).
+                        map((commandPhrase) => `● ${commandPhrase}`).
+                        join("\n")
+                }),
+                occurrenceLocation: "ConsoleCommandsParser.validateCommandLineInterfaceSpecification(commandLineInterfaceSpecification)"
+            });
+        }
+    }
+}
+(function (ConsoleCommandsParser) {
+    let ParametersTypes;
+    (function (ParametersTypes) {
+        ParametersTypes["string"] = "string";
+        ParametersTypes["number"] = "number";
+        ParametersTypes["boolean"] = "boolean";
+        ParametersTypes["JSON5"] = "JSON5";
+    })(ParametersTypes = ConsoleCommandsParser.ParametersTypes || (ConsoleCommandsParser.ParametersTypes = {}));
+})(ConsoleCommandsParser || (ConsoleCommandsParser = {}));
+exports.default = ConsoleCommandsParser;