@yamato-daiwa/es-extensions-nodejs 0.0.1 → 1.5.0-alpha.1

package/Distributable/ConsoleCommandsParser/ConsoleCommandsParser.js

@@ -0,0 +1,495 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+const InvalidConsoleCommandError_1 = __importDefault(require("../Logging/Errors/InvalidConsoleCommandError"));
+const json5_1 = __importDefault(require("json5"));
+const ConsoleCommandsParserLocalization_english_1 = __importDefault(require("./ConsoleCommandsParserLocalization.english"));
+class ConsoleCommandsParser {
+    constructor({ commandLineInterfaceSpecification, consciouslyInputtedArguments }) {
+        this.targetCommandOptions__eachOneWillBeRemovedOnceProcessed = [];
+        const helpReference = ConsoleCommandsParser.generateFullHelpReference(commandLineInterfaceSpecification);
+        const firstConsciouslyInputtedArgument = consciouslyInputtedArguments[0];
+        let targetCommandPhrase;
+        let targetCommandOptions;
+        let targetCommandOptionsSpecification;
+        if ((0, es_extensions_1.isUndefined)(firstConsciouslyInputtedArgument)) {
+            if ((0, es_extensions_1.isUndefined)(commandLineInterfaceSpecification.defaultCommand)) {
+                es_extensions_1.Logger.throwErrorAndLog({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.
+                            generateNoDefaultCommandPhraseAvailableErrorMessage(helpReference)
+                    }),
+                    title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                    occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+                });
+            }
+            targetCommandOptionsSpecification = commandLineInterfaceSpecification.defaultCommand;
+        }
+        else if (ConsoleCommandsParser.isCommandArgumentTheOption(firstConsciouslyInputtedArgument)) {
+            if ((0, es_extensions_1.isUndefined)(commandLineInterfaceSpecification.defaultCommand)) {
+                es_extensions_1.Logger.throwErrorAndLog({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.
+                            generateNoDefaultCommandPhraseAvailableErrorMessage(helpReference)
+                    }),
+                    title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                    occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+                });
+            }
+            targetCommandOptions = [...consciouslyInputtedArguments];
+            targetCommandOptionsSpecification = commandLineInterfaceSpecification.defaultCommand;
+        }
+        else {
+            if ((0, es_extensions_1.isUndefined)(commandLineInterfaceSpecification.commandPhrases)) {
+                es_extensions_1.Logger.throwErrorAndLog({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.
+                            generateFirstParameterLooksLikeCommandPhraseWhileNoCommandPhrasesAvailableErrorMessage({
+                            commandPhraseLikeArgument: firstConsciouslyInputtedArgument, helpReference
+                        })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                    occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+                });
+            }
+            targetCommandPhrase = firstConsciouslyInputtedArgument;
+            targetCommandOptions = consciouslyInputtedArguments.slice(1);
+            for (const [commandPhrase, commandOptionSpecification] of Object.entries(commandLineInterfaceSpecification.commandPhrases)) {
+                if (commandPhrase === targetCommandPhrase) {
+                    targetCommandOptionsSpecification = commandOptionSpecification;
+                    break;
+                }
+            }
+            if ((0, es_extensions_1.isUndefined)(targetCommandOptionsSpecification)) {
+                es_extensions_1.Logger.throwErrorAndLog({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: commandLineInterfaceSpecification.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.generateUnknownCommandPhraseErrorMessage({
+                            inputtedCommandPhrase: targetCommandPhrase, helpReference
+                        })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                    occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+                });
+            }
+        }
+        this.applicationName = commandLineInterfaceSpecification.applicationName;
+        this.targetCommandPhrase = targetCommandPhrase;
+        this.targetCommandOptions = targetCommandOptions;
+        this.targetCommandOptionsSpecification = targetCommandOptionsSpecification;
+    }
+    static parse(argumentsVector, commandLineInterfaceSpecification) {
+        if (!Array.isArray(argumentsVector)) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: commandLineInterfaceSpecification.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.
+                        generateArgumentsVectorIsNotArrayErrorMessage(argumentsVector)
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(argumentsVector, commandLineInterfaceSpecification)"
+            });
+        }
+        if (argumentsVector.length < ConsoleCommandsParser.MINIMAL_ARGUMENTS_IN_VALID_CONSOLE_COMMAND) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: commandLineInterfaceSpecification.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.
+                        generateArgumentsVectorHasNotEnoughElementsErrorMessage({
+                        arrayedConsoleCommand: argumentsVector,
+                        minimalElementsCount: ConsoleCommandsParser.MINIMAL_ARGUMENTS_IN_VALID_CONSOLE_COMMAND
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(argumentsVector, commandLineInterfaceSpecification)"
+            });
+        }
+        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.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: commandLineInterfaceSpecification.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.
+                        generateArgumentsVectorHasNonStringElementsErrorMessage(nonStringArguments)
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(argumentsVector, commandLineInterfaceSpecification)"
+            });
+        }
+        const dataHoldingSelfInstance = new ConsoleCommandsParser({
+            consciouslyInputtedArguments, commandLineInterfaceSpecification
+        });
+        return {
+            NodeJS_InterpreterAbsolutePath,
+            executableFileAbsolutePath,
+            phrase: dataHoldingSelfInstance.targetCommandPhrase,
+            ...dataHoldingSelfInstance.getParsedOptionsAndParameters()
+        };
+    }
+    static setLocalization(newLocalization) {
+        ConsoleCommandsParser.localization = newLocalization;
+    }
+    getParsedOptionsAndParameters() {
+        if ((0, es_extensions_1.isUndefined)(this.targetCommandOptionsSpecification)) {
+            return {};
+        }
+        const parsedOptions = {};
+        this.targetCommandOptions__eachOneWillBeRemovedOnceProcessed.push(...this.targetCommandOptions ?? []);
+        for (const [optionKey, optionSpecification] of Object.entries(this.targetCommandOptionsSpecification)) {
+            const optionKey__withoutPrepended2NDashes = optionKey.startsWith("--") ? optionKey.slice(2) : optionKey;
+            const optionKey__withPrepended2NDashes = `--${optionKey__withoutPrepended2NDashes}`;
+            const optionFinalName = optionSpecification.newName ?? optionKey__withoutPrepended2NDashes;
+            let shortcut__withPrependedNDash;
+            if ((0, es_extensions_1.isNotUndefined)(optionSpecification.shortcut)) {
+                shortcut__withPrependedNDash = optionSpecification.shortcut.startsWith("-") ?
+                    optionSpecification.shortcut : `-${optionSpecification.shortcut}`;
+            }
+            const arrayIndexOfTargetOptionKey = this.targetCommandOptions__eachOneWillBeRemovedOnceProcessed.findIndex((commandOption) => commandOption === optionKey__withPrepended2NDashes || commandOption === shortcut__withPrependedNDash);
+            if (optionSpecification.type === ConsoleCommandsParser.ParametersTypes.boolean) {
+                if (arrayIndexOfTargetOptionKey !== -1) {
+                    this.targetCommandOptions__eachOneWillBeRemovedOnceProcessed.splice(arrayIndexOfTargetOptionKey, 1);
+                }
+                parsedOptions[optionFinalName] = arrayIndexOfTargetOptionKey !== -1;
+                continue;
+            }
+            if (arrayIndexOfTargetOptionKey === -1) {
+                if (optionSpecification.required) {
+                    es_extensions_1.Logger.throwErrorAndLog({
+                        errorInstance: new InvalidConsoleCommandError_1.default({
+                            applicationName: this.applicationName,
+                            messageSpecificPart: ConsoleCommandsParser.localization.generateRequiredOptionKeyIsMissingErrorMessage({
+                                commandPhrase: this.targetCommandPhrase,
+                                missingOptionKey: optionKey__withPrepended2NDashes,
+                                commandHelpReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                                    commandPhrase: this.targetCommandPhrase,
+                                    commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                                })
+                            })
+                        }),
+                        title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                        occurrenceLocation: "ConsoleCommandsParser.parse(parametersObject) -> ..."
+                    });
+                }
+                continue;
+            }
+            const targetOptionPotentialValue = this.targetCommandOptions__eachOneWillBeRemovedOnceProcessed[arrayIndexOfTargetOptionKey + 1];
+            if ((0, es_extensions_1.isUndefined)(targetOptionPotentialValue)) {
+                es_extensions_1.Logger.throwErrorAndLog({
+                    errorInstance: new InvalidConsoleCommandError_1.default({
+                        applicationName: this.applicationName,
+                        messageSpecificPart: ConsoleCommandsParser.localization.generateNoValueFollowingTheKeyOfNonBooleanOptionErrorMessage({
+                            targetOptionKey: optionKey__withPrepended2NDashes,
+                            commandHelpReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                                commandPhrase: this.targetCommandPhrase, commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                            })
+                        })
+                    }),
+                    title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                    occurrenceLocation: "ConsoleCommandsParser.parse(parametersObject) -> ..."
+                });
+            }
+            switch (optionSpecification.type) {
+                case ConsoleCommandsParser.ParametersTypes.string: {
+                    parsedOptions[optionFinalName] = this.processStringTypeOptionValue({
+                        targetOptionRawValue: targetOptionPotentialValue,
+                        optionKey__withPrepended2NDashes,
+                        optionSpecification
+                    });
+                    break;
+                }
+                case ConsoleCommandsParser.ParametersTypes.number: {
+                    parsedOptions[optionFinalName] = this.processNumberTypeOptionValue({
+                        targetOptionRawValue: targetOptionPotentialValue,
+                        optionKey__withPrepended2NDashes,
+                        optionSpecification
+                    });
+                    break;
+                }
+                case ConsoleCommandsParser.ParametersTypes.JSON5: {
+                    const targetParsedJSON5_ParameterValue = this.
+                        extractAndValidateParsedJSON5_ParameterValue({
+                        targetOptionRawValue: targetOptionPotentialValue,
+                        optionKey__withPrepended2NDashes,
+                        optionSpecification
+                    });
+                    if ((0, es_extensions_1.isNotUndefined)(targetParsedJSON5_ParameterValue)) {
+                        parsedOptions[optionFinalName] = targetParsedJSON5_ParameterValue;
+                    }
+                    break;
+                }
+                default: {
+                    es_extensions_1.Logger.throwErrorAndLog({
+                        errorType: "InvalidConsoleCommandOptionSpecification",
+                        title: "Invalid console command option specification",
+                        description: ConsoleCommandsParser.localization.generateInvalidOptionTypeErrorMessage({
+                            optionName: optionFinalName
+                        }),
+                        occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+                    });
+                }
+            }
+            this.targetCommandOptions__eachOneWillBeRemovedOnceProcessed.splice(arrayIndexOfTargetOptionKey, 2);
+        }
+        if (this.targetCommandOptions__eachOneWillBeRemovedOnceProcessed.length > 0) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.generateUnknownOptionsFoundForSpecificCommandErrorMessage({
+                        commandPhrase: this.targetCommandPhrase,
+                        commandReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                            commandPhrase: this.targetCommandPhrase, commandOptionsSpecification: this.targetCommandOptionsSpecification
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+            });
+        }
+        return parsedOptions;
+    }
+    processStringTypeOptionValue({ targetOptionRawValue, optionKey__withPrepended2NDashes, optionSpecification }) {
+        const { allowedAlternatives } = optionSpecification;
+        if ((0, es_extensions_1.isNotUndefined)(allowedAlternatives) && !allowedAlternatives.includes(targetOptionRawValue)) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.generateOptionValueIsNotAmongAllowedAlternativesErrorMessage({
+                        targetOptionKey: optionKey__withPrepended2NDashes,
+                        actualOptionValue: targetOptionRawValue,
+                        commandReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                            commandPhrase: this.targetCommandPhrase, commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(parametersObject) -> ..."
+            });
+        }
+        return targetOptionRawValue;
+    }
+    processNumberTypeOptionValue({ targetOptionRawValue, optionKey__withPrepended2NDashes, optionSpecification }) {
+        const { numbersSet, minimalValue, maximalValue } = optionSpecification;
+        const targetOptionParsedValue = Number(targetOptionRawValue);
+        if (Number.isNaN(targetOptionParsedValue)) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.generateUnparsableNumericOptionValueErrorMessage({
+                        targetOptionKey: optionKey__withPrepended2NDashes,
+                        actualOptionValue: targetOptionRawValue,
+                        commandReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                            commandPhrase: this.targetCommandPhrase, commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(parametersObject) -> ..."
+            });
+        }
+        let optionValueMatchingWithExpectedNumberSet;
+        switch (numbersSet) {
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.naturalNumber: {
+                optionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNaturalNumber)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.nonNegativeInteger: {
+                optionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNonNegativeInteger)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeInteger: {
+                optionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNegativeInteger)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeIntegerOrZero: {
+                optionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNegativeIntegerOrZero)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.anyInteger: {
+                optionValueMatchingWithExpectedNumberSet = Number.isInteger(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.positiveDecimalFraction: {
+                optionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isPositiveDecimalFraction)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.negativeDecimalFraction: {
+                optionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isNegativeDecimalFraction)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.decimalFractionOfAnySign: {
+                optionValueMatchingWithExpectedNumberSet = (0, es_extensions_1.isDecimalFractionOfAnySign)(targetOptionParsedValue);
+                break;
+            }
+            case es_extensions_1.RawObjectDataProcessor.NumbersSets.anyRealNumber: {
+                optionValueMatchingWithExpectedNumberSet = true;
+                break;
+            }
+        }
+        if (!optionValueMatchingWithExpectedNumberSet) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.
+                        generatedNumericOptionValueIsNotBelongToExpectedNumbersSetErrorMessage({
+                        targetOptionKey: optionKey__withPrepended2NDashes,
+                        expectedNumbersSet: numbersSet,
+                        actualOptionValue: targetOptionRawValue,
+                        commandReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(parametersObject) -> ..."
+            });
+        }
+        if ((0, es_extensions_1.isNotUndefined)(minimalValue) && targetOptionParsedValue <= minimalValue) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.
+                        generateNumericValueIsSmallerThanRequiredMinimumErrorMessage({
+                        targetOptionKey: optionKey__withPrepended2NDashes,
+                        requiredMinimum: minimalValue,
+                        actualOptionValue: targetOptionRawValue,
+                        commandReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(parametersObject) -> ..."
+            });
+        }
+        if ((0, es_extensions_1.isNotUndefined)(maximalValue) && targetOptionParsedValue >= maximalValue) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.
+                        generateNumericValueIsGreaterThanAllowedMaximumErrorMessage({
+                        targetOptionKey: optionKey__withPrepended2NDashes,
+                        allowedMaximum: maximalValue,
+                        actualOptionValue: targetOptionRawValue,
+                        commandReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                            commandPhrase: this.targetCommandPhrase,
+                            commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(parametersObject) -> ..."
+            });
+        }
+        return targetOptionParsedValue;
+    }
+    extractAndValidateParsedJSON5_ParameterValue({ targetOptionRawValue, optionKey__withPrepended2NDashes, optionSpecification }) {
+        let targetParameterParsedValue;
+        try {
+            targetParameterParsedValue = json5_1.default.parse(targetOptionRawValue);
+        }
+        catch (error) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new InvalidConsoleCommandError_1.default({
+                    applicationName: this.applicationName,
+                    messageSpecificPart: ConsoleCommandsParser.localization.generateMalformedJSON5_OptionErrorMessage({
+                        targetOptionKey: optionKey__withPrepended2NDashes,
+                        commandReference: ConsoleCommandsParser.generateSingleCommendHelpReference({
+                            commandPhrase: this.targetCommandPhrase, commandOptionsSpecification: this.targetCommandOptionsSpecification ?? {}
+                        })
+                    })
+                }),
+                title: InvalidConsoleCommandError_1.default.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+            });
+        }
+        const validationResult = es_extensions_1.RawObjectDataProcessor.
+            process(targetParameterParsedValue, optionSpecification.validValueSpecification);
+        if (validationResult.rawDataIsInvalid) {
+            es_extensions_1.Logger.throwErrorAndLog({
+                errorInstance: new es_extensions_1.InvalidExternalDataError({
+                    customMessage: ConsoleCommandsParser.localization.generateJSON5_OptionDoesNotMatchWithValidDataSchemaErrorMessage({
+                        targetOptionKey: optionKey__withPrepended2NDashes,
+                        formattedValidationErrorsMessages: es_extensions_1.RawObjectDataProcessor.
+                            formatValidationErrorsList(validationResult.validationErrorsMessages)
+                    })
+                }),
+                title: es_extensions_1.InvalidExternalDataError.DEFAULT_TITLE,
+                occurrenceLocation: "ConsoleCommandsParser.parse(arrayedConsoleCommand, commandLineInterfaceSpecification)"
+            });
+        }
+        return validationResult.processedData;
+    }
+    static isCommandArgumentTheOption(consoleCommandArgument) {
+        return consoleCommandArgument.startsWith("-");
+    }
+    static generateFullHelpReference(commandLineInterfaceSpecification) {
+        let accumulatingValue = "";
+        if ((0, es_extensions_1.isNotUndefined)(commandLineInterfaceSpecification.defaultCommand)) {
+            accumulatingValue = "Has default command\n";
+            for (const [argumentName, argumentSpecification] of Object.entries(commandLineInterfaceSpecification.defaultCommand)) {
+                accumulatingValue = `${argumentName}: ${argumentSpecification.type}\n`;
+            }
+        }
+        if ((0, es_extensions_1.isNotUndefined)(commandLineInterfaceSpecification.commandPhrases)) {
+            for (const [commandPhrase, argumentsSpecification] of Object.entries(commandLineInterfaceSpecification.commandPhrases)) {
+                accumulatingValue = `${accumulatingValue}${commandPhrase}:\n`;
+                if ((0, es_extensions_1.isUndefined)(argumentsSpecification)) {
+                    continue;
+                }
+                for (const [argumentName, argumentSpecification] of Object.entries(argumentsSpecification)) {
+                    accumulatingValue = `${accumulatingValue}\n  ${argumentName}: ${argumentSpecification.type}`;
+                }
+            }
+        }
+        return accumulatingValue;
+    }
+    static generateSingleCommendHelpReference({ commandPhrase, commandOptionsSpecification }) {
+        let accumulatingValue = (0, es_extensions_1.isNotUndefined)(commandPhrase) ? commandPhrase : "(Default command)";
+        for (const [argumentName, argumentSpecification] of Object.entries(commandOptionsSpecification)) {
+            accumulatingValue = `${accumulatingValue}:\n ${argumentName}: ${argumentSpecification.type}`;
+        }
+        return accumulatingValue;
+    }
+}
+ConsoleCommandsParser.MINIMAL_ARGUMENTS_IN_VALID_CONSOLE_COMMAND = 2;
+ConsoleCommandsParser.localization = ConsoleCommandsParserLocalization_english_1.default;
+(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;

package/Distributable/ConsoleCommandsParser/ConsoleCommandsParserLocalization.english.d.ts

@@ -0,0 +1,3 @@
+import ConsoleCommandsParser from "./ConsoleCommandsParser";
+declare const ConsoleCommandsParserLocalization__English: ConsoleCommandsParser.Localization;
+export default ConsoleCommandsParserLocalization__English;

package/Distributable/ConsoleCommandsParser/ConsoleCommandsParserLocalization.english.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+const ConsoleCommandsParserLocalization__English = {
+    generateArgumentsVectorIsNotArrayErrorMessage: (argumentsVector) => "Expected that the arguments vector will be an array while actually it did not pass 'Array.isArray()' check and" +
+        `has the value:\n${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(argumentsVector)}`,
+    generateArgumentsVectorHasNotEnoughElementsErrorMessage: ({ minimalElementsCount, arrayedConsoleCommand }) => `The valid arguments vector must be an array of at least ${minimalElementsCount} elements while actually is has ` +
+        `${arrayedConsoleCommand.length} elements and value:\n${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(arrayedConsoleCommand)}`,
+    generateArgumentsVectorHasNonStringElementsErrorMessage: (nonStringElements) => "The valid arguments vector must be an array of the strings while below arguments are not strings:\n" +
+        `${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(nonStringElements)}`,
+    generateNoDefaultCommandPhraseAvailableErrorMessage: (helpReference) => "This application has not the default command. Please specify explicitly one of mentioned below command phrases:\n" +
+        `${helpReference}`,
+    generateFirstParameterLooksLikeCommandPhraseWhileNoCommandPhrasesAvailableErrorMessage: ({ commandPhraseLikeArgument, helpReference }) => `'${commandPhraseLikeArgument}' seems like the command phrase while no command phrases available for this application:\n` +
+        `${helpReference}`,
+    generateUnknownCommandPhraseErrorMessage: ({ inputtedCommandPhrase, helpReference }) => `The command phrase '${inputtedCommandPhrase}' is unknown. ` +
+        `Please input one of below available command phrases:\n${helpReference}`,
+    generateUnknownOptionsFoundForSpecificCommandErrorMessage: ({ commandPhrase, commandReference }) => "Below options are unknown for the " +
+        `"${(0, es_extensions_1.isNotUndefined)(commandPhrase) ? `command "${commandPhrase}"` : "default command"}".` +
+        `Please check the  reference for this command:\n${commandReference}`,
+    generateInvalidOptionTypeErrorMessage: ({ optionName }) => `Invalid type has been specified for the option '${optionName}'.`,
+    generateRequiredOptionKeyIsMissingErrorMessage: ({ missingOptionKey, commandPhrase, commandHelpReference }) => `The option '${missingOptionKey}' is required for the ` +
+        `${(0, es_extensions_1.isNotUndefined)(commandPhrase) ? `command '${commandPhrase}'` : "default command"}.` +
+        `Please check the reference for this command:\n${commandHelpReference}`,
+    generateNoValueFollowingTheKeyOfNonBooleanOptionErrorMessage: ({ targetOptionKey, commandHelpReference }) => `No value following the key '${targetOptionKey}' of non-boolean option has been specified.` +
+        `Please check the reference for this command:\n${commandHelpReference}`,
+    generateOptionValueIsNotAmongAllowedAlternativesErrorMessage: ({ targetOptionKey, actualOptionValue, commandReference }) => `The value '${actualOptionValue}' of the option '${targetOptionKey}' is not among allowed alternatives. ` +
+        `Please check the reference for this command:\n${commandReference}`,
+    generateUnparsableNumericOptionValueErrorMessage: ({ actualOptionValue, targetOptionKey, commandReference }) => `The value '${actualOptionValue}' of the option '${targetOptionKey}' is not valid numeric value.` +
+        `Please check the reference for this command:\n${commandReference}`,
+    generateReadableNumbersSet(numberSet) {
+        return es_extensions_1.RawObjectDataProcessorLocalization__English.numbersSet(numberSet);
+    },
+    generatedNumericOptionValueIsNotBelongToExpectedNumbersSetErrorMessage({ targetOptionKey, expectedNumbersSet, actualOptionValue, commandReference }) {
+        return `The value '${actualOptionValue}' of the option '${targetOptionKey}' is not is in not member of ` +
+            `'${this.generateReadableNumbersSet(expectedNumbersSet)}' set as required. ` +
+            `Please check the reference for target command:\n${commandReference}`;
+    },
+    generateNumericValueIsSmallerThanRequiredMinimumErrorMessage({ targetOptionKey, requiredMinimum, actualOptionValue, commandReference }) {
+        return `The value '${actualOptionValue}' of the option '${targetOptionKey}' is less than required minimal value ` +
+            `${requiredMinimum} set as required.\n Please check the reference for this target command:\n${commandReference}`;
+    },
+    generateNumericValueIsGreaterThanAllowedMaximumErrorMessage({ targetOptionKey, allowedMaximum, actualOptionValue, commandReference }) {
+        return `The value '${actualOptionValue}' of the option '${targetOptionKey}' is greater that allowed maximal value ` +
+            `${allowedMaximum}. \n Please check the reference for target command:\n${commandReference}`;
+    },
+    generateMalformedJSON5_OptionErrorMessage: ({ targetOptionKey, commandReference }) => `The value of the option '${targetOptionKey}' is not valid JSON5.` +
+        `Please check the reference for this command:\n${commandReference}`,
+    generateJSON5_OptionDoesNotMatchWithValidDataSchemaErrorMessage: ({ targetOptionKey, formattedValidationErrorsMessages }) => `The JSON5-type value of the option '${targetOptionKey}' does not match with valid data schema:\n` +
+        `${formattedValidationErrorsMessages}`
+};
+exports.default = ConsoleCommandsParserLocalization__English;

package/Distributable/DateTime/NodeJS_Timer.d.ts

@@ -1,6 +1,6 @@
 import { Timer } from "@yamato-daiwa/es-extensions";
 export default class NodeJS_Timer extends Timer {
-    private timeout;
+    private nativeTimeout;
     start(): void;
     stop(): void;
     restart(): void;

package/Distributable/DateTime/NodeJS_Timer.js

@@ -1,13 +1,16 @@
-import { Timer, secondsToMilliseconds } from "@yamato-daiwa/es-extensions";
-export default class NodeJS_Timer extends Timer {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class NodeJS_Timer extends es_extensions_1.Timer {
     start() {
-        this.timeout = setTimeout(this.onElapsed.bind(this), secondsToMilliseconds(this.period__seconds));
+        this.nativeTimeout = setTimeout(this.onElapsed.bind(this), (0, es_extensions_1.secondsToMilliseconds)(this.period__seconds));
     }
     stop() {
-        clearTimeout(this.timeout);
+        clearTimeout(this.nativeTimeout);
     }
     restart() {
         this.stop();
         this.start();
     }
 }
+exports.default = NodeJS_Timer;

package/Distributable/Logging/Errors/InvalidConsoleCommandError.d.ts

@@ -0,0 +1,23 @@
+declare class InvalidConsoleCommandError extends Error {
+    static readonly NAME: string;
+    static get DEFAULT_TITLE(): string;
+    private static localization;
+    static setLocalization(localization: InvalidConsoleCommandError.Localization): void;
+    constructor(parametersObject: InvalidConsoleCommandError.ConstructorParametersObject);
+}
+declare namespace InvalidConsoleCommandError {
+    type ConstructorParametersObject = Localization.GenericDescriptionPartTemplateParameters | {
+        customMessage: string;
+    };
+    type Localization = {
+        readonly defaultTitle: string;
+        readonly genericDescriptionPartTemplate: (parametersObject: Localization.GenericDescriptionPartTemplateParameters) => string;
+    };
+    namespace Localization {
+        type GenericDescriptionPartTemplateParameters = {
+            applicationName: string;
+            messageSpecificPart?: string;
+        };
+    }
+}
+export default InvalidConsoleCommandError;

package/Distributable/Logging/Errors/InvalidConsoleCommandError.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InvalidConsoleCommandErrorLocalization__English_1 = __importDefault(require("./InvalidConsoleCommandErrorLocalization__English"));
+class InvalidConsoleCommandError extends Error {
+    constructor(parametersObject) {
+        super();
+        this.name = InvalidConsoleCommandError.NAME;
+        if ("customMessage" in parametersObject) {
+            this.message = parametersObject.customMessage;
+        }
+        else {
+            this.message = InvalidConsoleCommandError.localization.genericDescriptionPartTemplate(parametersObject);
+        }
+    }
+    static get DEFAULT_TITLE() {
+        return InvalidConsoleCommandError.localization.defaultTitle;
+    }
+    static setLocalization(localization) {
+        InvalidConsoleCommandError.localization = localization;
+    }
+}
+InvalidConsoleCommandError.NAME = "InvalidConsoleCommandError";
+InvalidConsoleCommandError.localization = InvalidConsoleCommandErrorLocalization__English_1.default;
+exports.default = InvalidConsoleCommandError;

package/Distributable/Logging/Errors/InvalidConsoleCommandErrorLocalization__English.d.ts

@@ -0,0 +1,3 @@
+import InvalidConsoleCommandError from "./InvalidConsoleCommandError";
+declare const InvalidConsoleCommandErrorLocalization__English: InvalidConsoleCommandError.Localization;
+export default InvalidConsoleCommandErrorLocalization__English;

package/Distributable/Logging/Errors/InvalidConsoleCommandErrorLocalization__English.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+const InvalidConsoleCommandErrorLocalization__English = {
+    defaultTitle: "Invalid console command",
+    genericDescriptionPartTemplate: (parametersObject) => `Invalid console command for the application '${parametersObject.applicationName}'` +
+        `${(0, es_extensions_1.insertSubstring)(parametersObject.messageSpecificPart, {
+            modifier: (messageSpecificPart) => `\n${messageSpecificPart}`
+        })}`
+};
+exports.default = InvalidConsoleCommandErrorLocalization__English;