@akylas/nativescript-cli 8.7.2

package/lib/common/services/analytics/google-analytics-custom-dimensions.d.ts

@@ -0,0 +1,16 @@
+declare const enum GoogleAnalyticsCustomDimensions {
+	cliVersion = "cd1",
+	projectType = "cd2",
+	clientID = "cd3",
+	sessionID = "cd4",
+	client = "cd5",
+	nodeVersion = "cd6",
+	// playgroundId = "cd7",
+	// usedTutorial = "cd8",
+	isShared = "cd9",
+	// companyName = "cd10",
+	// companyCountry = "cd11",
+	// companyRevenue = "cd12",
+	// companyIndustries = "cd13",
+	// companyEmployeeCount = "cd14",
+}

package/lib/common/services/auto-completion-service.js

@@ -0,0 +1,265 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoCompletionService = void 0;
+const os_1 = require("os");
+const path = require("path");
+const util = require("util");
+const _ = require("lodash");
+const decorators_1 = require("../decorators");
+const yok_1 = require("../yok");
+class AutoCompletionService {
+    constructor($fs, $childProcess, $logger, $staticConfig, $hostInfo) {
+        this.$fs = $fs;
+        this.$childProcess = $childProcess;
+        this.$logger = $logger;
+        this.$staticConfig = $staticConfig;
+        this.$hostInfo = $hostInfo;
+        this.scriptsOk = true;
+        this.scriptsUpdated = false;
+        this.disableAnalytics = true;
+    }
+    get shellProfiles() {
+        return [
+            this.getHomePath(".bashrc"),
+            this.getHomePath(".zshrc"),
+        ];
+    }
+    get cliRunCommandsFile() {
+        let cliRunCommandsFile = this.getHomePath(util.format(".%src", this.$staticConfig.CLIENT_NAME.toLowerCase()));
+        if (this.$hostInfo.isWindows) {
+            cliRunCommandsFile = cliRunCommandsFile.replace(/\\/g, "/");
+        }
+        return cliRunCommandsFile;
+    }
+    getTabTabObsoleteRegex(clientName) {
+        const tabTabStartPoint = util.format(AutoCompletionService.TABTAB_COMPLETION_START_REGEX_PATTERN, clientName.toLowerCase());
+        const tabTabEndPoint = util.format(AutoCompletionService.TABTAB_COMPLETION_END_REGEX_PATTERN, clientName.toLowerCase());
+        const tabTabRegex = new RegExp(util.format("%s[\\s\\S]*%s", tabTabStartPoint, tabTabEndPoint));
+        return tabTabRegex;
+    }
+    getTabTabCompletionsRegex() {
+        return new RegExp(util.format("%s[\\s\\S]*%s", AutoCompletionService.GENERATED_TABTAB_COMPLETION_START, AutoCompletionService.GENERATED_TABTAB_COMPLETION_END));
+    }
+    removeObsoleteAutoCompletion() {
+        const shellProfilesToBeCleared = this.shellProfiles;
+        shellProfilesToBeCleared.push(this.getHomePath(".profile"));
+        shellProfilesToBeCleared.forEach((file) => {
+            try {
+                const text = this.$fs.readText(file);
+                let newText = text.replace(this.getTabTabObsoleteRegex(this.$staticConfig.CLIENT_NAME), "");
+                if (this.$staticConfig.CLIENT_NAME_ALIAS) {
+                    newText = newText.replace(this.getTabTabObsoleteRegex(this.$staticConfig.CLIENT_NAME_ALIAS), "");
+                }
+                if (newText !== text) {
+                    this.$logger.trace("Remove obsolete AutoCompletion from file %s.", file);
+                    this.$fs.writeFile(file, newText);
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    this.$logger.trace("Error while trying to disable autocompletion for '%s' file. Error is:\n%s", error.toString());
+                }
+            }
+        });
+    }
+    removeOboleteTabTabCompletion(text) {
+        try {
+            let newText = text.replace(this.getTabTabObsoleteRegex("ns"), "");
+            newText = newText.replace(this.getTabTabObsoleteRegex("nsc"), "");
+            newText = newText.replace(this.getTabTabObsoleteRegex("nativescript"), "");
+            newText = newText.replace(this.getTabTabObsoleteRegex("tns"), "");
+            return newText;
+        }
+        catch (error) {
+            this.$logger.trace("Error while trying to disable autocompletion for '%s' file. Error is:\n%s", error.toString());
+            return text;
+        }
+    }
+    get completionAliasDefinition() {
+        const pattern = "compdef _nativescript.js_yargs_completions %s";
+        const ns = util.format(pattern, "ns");
+        const tns = util.format(pattern, "tns");
+        return util.format("\n%s\n%s\n%s\n", ns, tns, AutoCompletionService.GENERATED_TABTAB_COMPLETION_END);
+    }
+    get completionShellScriptContent() {
+        const startText = util.format(AutoCompletionService.COMPLETION_START_COMMENT_PATTERN, this.$staticConfig.CLIENT_NAME.toLowerCase());
+        const content = util.format("if [ -f %s ]; then \n    source %s \nfi", this.cliRunCommandsFile, this.cliRunCommandsFile);
+        const endText = util.format(AutoCompletionService.COMPLETION_END_COMMENT_PATTERN, this.$staticConfig.CLIENT_NAME.toLowerCase());
+        return util.format("\n%s\n%s\n%s\n", startText, content, endText);
+    }
+    isAutoCompletionEnabled() {
+        let result = true;
+        _.each(this.shellProfiles, (filePath) => {
+            result =
+                this.isNewAutoCompletionEnabledInFile(filePath) ||
+                    this.isObsoleteAutoCompletionEnabledInFile(filePath);
+            if (!result) {
+                return false;
+            }
+        });
+        return result;
+    }
+    disableAutoCompletion() {
+        _.each(this.shellProfiles, (shellFile) => this.removeAutoCompletionFromShellScript(shellFile));
+        this.removeObsoleteAutoCompletion();
+        if (this.scriptsOk && this.scriptsUpdated) {
+            this.$logger.info("Restart your shell to disable command auto-completion.");
+        }
+    }
+    enableAutoCompletion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.updateCLIShellScript();
+            _.each(this.shellProfiles, (shellFile) => this.addAutoCompletionToShellScript(shellFile));
+            this.removeObsoleteAutoCompletion();
+            if (this.scriptsOk && this.scriptsUpdated) {
+                this.$logger.info("Restart your shell to enable command auto-completion.");
+            }
+        });
+    }
+    isObsoleteAutoCompletionEnabled() {
+        let result = true;
+        _.each(this.shellProfiles, (shellProfile) => {
+            result = this.isObsoleteAutoCompletionEnabledInFile(shellProfile);
+            if (!result) {
+                return false;
+            }
+        });
+        return result;
+    }
+    isNewAutoCompletionEnabledInFile(fileName) {
+        try {
+            const data = this.$fs.readText(fileName);
+            if (data && data.indexOf(this.completionShellScriptContent) !== -1) {
+                return true;
+            }
+        }
+        catch (err) {
+            this.$logger.trace("Error while checking is autocompletion enabled in file %s. Error is: '%s'", fileName, err.toString());
+        }
+        return false;
+    }
+    isObsoleteAutoCompletionEnabledInFile(fileName) {
+        try {
+            const text = this.$fs.readText(fileName);
+            return !!(text.match(this.getTabTabObsoleteRegex(this.$staticConfig.CLIENT_NAME)) ||
+                text.match(this.getTabTabObsoleteRegex(this.$staticConfig.CLIENT_NAME)));
+        }
+        catch (err) {
+            this.$logger.trace("Error while checking is obsolete autocompletion enabled in file %s. Error is: '%s'", fileName, err.toString());
+        }
+    }
+    addAutoCompletionToShellScript(fileName) {
+        try {
+            if (!this.isNewAutoCompletionEnabledInFile(fileName) ||
+                this.isObsoleteAutoCompletionEnabledInFile(fileName)) {
+                this.$logger.trace("AutoCompletion is not enabled in %s file. Trying to enable it.", fileName);
+                this.$fs.appendFile(fileName, this.completionShellScriptContent);
+                this.scriptsUpdated = true;
+            }
+        }
+        catch (err) {
+            this.$logger.info("Unable to update %s. Command-line completion might not work.", fileName);
+            if ((err.code === "EPERM" || err.code === "EACCES") &&
+                !this.$hostInfo.isWindows &&
+                process.env.SUDO_USER) {
+                this.$logger.info("To enable command-line completion, run '$ %s autocomplete enable'.", this.$staticConfig.CLIENT_NAME);
+            }
+            this.$logger.trace(err);
+            this.scriptsOk = false;
+        }
+    }
+    removeAutoCompletionFromShellScript(fileName) {
+        try {
+            if (this.isNewAutoCompletionEnabledInFile(fileName)) {
+                this.$logger.trace("AutoCompletion is enabled in %s file. Trying to disable it.", fileName);
+                let data = this.$fs.readText(fileName);
+                data = data.replace(this.completionShellScriptContent, "");
+                this.$fs.writeFile(fileName, data);
+                this.scriptsUpdated = true;
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                this.$logger.info("Failed to update %s. Auto-completion may still work or work incorrectly. ", fileName);
+                this.$logger.info(err);
+                this.scriptsOk = false;
+            }
+        }
+    }
+    updateCLIShellScript() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filePath = this.cliRunCommandsFile;
+            try {
+                let doUpdate = true;
+                if (this.$fs.exists(filePath)) {
+                    const contents = this.$fs.readText(filePath);
+                    const regExp = new RegExp(AutoCompletionService.GENERATED_TABTAB_COMPLETION_START);
+                    let matchCondition = contents.match(regExp);
+                    if (matchCondition) {
+                        doUpdate = false;
+                    }
+                }
+                if (doUpdate) {
+                    const clientExecutableFileName = (this.$staticConfig.CLIENT_NAME_ALIAS || this.$staticConfig.CLIENT_NAME).toLowerCase();
+                    const pathToExecutableFile = path.join(__dirname, `../../../bin/${clientExecutableFileName}.js`);
+                    if (this.$fs.exists(filePath)) {
+                        const existingText = this.$fs.readText(filePath);
+                        let newText = existingText.replace(this.getTabTabCompletionsRegex(), "");
+                        newText = this.removeOboleteTabTabCompletion(newText);
+                        if (newText !== existingText) {
+                            this.$logger.trace("Remove existing AutoCompletion from file %s.", filePath);
+                            this.$fs.writeFile(filePath, newText);
+                        }
+                    }
+                    this.$fs.appendFile(filePath, `\n${AutoCompletionService.GENERATED_TABTAB_COMPLETION_START}\n`);
+                    yield this.$childProcess.exec(`"${process.argv[0]}" "${pathToExecutableFile}" completion_generate_script >> "${filePath}"`);
+                    this.$fs.appendFile(filePath, this.completionAliasDefinition);
+                    this.$fs.chmod(filePath, "0644");
+                }
+            }
+            catch (err) {
+                this.$logger.info("Failed to update %s. Auto-completion may not work. ", filePath);
+                this.$logger.trace(err);
+                this.scriptsOk = false;
+            }
+        });
+    }
+    getHomePath(fileName) {
+        return path.join((0, os_1.homedir)(), fileName);
+    }
+}
+AutoCompletionService.COMPLETION_START_COMMENT_PATTERN = "###-%s-completion-start-###";
+AutoCompletionService.COMPLETION_END_COMMENT_PATTERN = "###-%s-completion-end-###";
+AutoCompletionService.TABTAB_COMPLETION_START_REGEX_PATTERN = "###-begin-%s-completion-###";
+AutoCompletionService.TABTAB_COMPLETION_END_REGEX_PATTERN = "###-end-%s-completion-###";
+AutoCompletionService.GENERATED_TABTAB_COMPLETION_END = "###-end-ns-completions-section-###";
+AutoCompletionService.GENERATED_TABTAB_COMPLETION_START = "###-begin-ns-completions-section-###";
+__decorate([
+    (0, decorators_1.cache)()
+], AutoCompletionService.prototype, "shellProfiles", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AutoCompletionService.prototype, "cliRunCommandsFile", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AutoCompletionService.prototype, "completionAliasDefinition", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AutoCompletionService.prototype, "completionShellScriptContent", null);
+exports.AutoCompletionService = AutoCompletionService;
+yok_1.injector.register("autoCompletionService", AutoCompletionService);

package/lib/common/services/cancellation.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const choki = require("chokidar");
+const path = require("path");
+const os = require("os");
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class CancellationService {
+    constructor($fs, $logger, $hostInfo) {
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$hostInfo = $hostInfo;
+        this.watches = {};
+        if (this.$hostInfo.isWindows) {
+            this.$fs.createDirectory(CancellationService.killSwitchDir);
+        }
+    }
+    begin(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.$hostInfo.isWindows) {
+                return;
+            }
+            const triggerFile = CancellationService.makeKillSwitchFileName(name);
+            if (!this.$fs.exists(triggerFile)) {
+                this.$fs.writeFile(triggerFile, "");
+            }
+            this.$logger.trace("Starting watch on killswitch %s", triggerFile);
+            const watcher = choki
+                .watch(triggerFile, { ignoreInitial: true })
+                .on("unlink", (filePath) => {
+                this.$logger.info(`Exiting process as the file ${filePath} has been deleted. Probably reinstalling CLI while there's a working instance.`);
+                process.exit(132);
+            });
+            if (watcher) {
+                this.watches[name] = watcher;
+            }
+        });
+    }
+    end(name) {
+        const watcher = this.watches[name];
+        if (watcher) {
+            delete this.watches[name];
+            watcher.close().then().catch();
+        }
+    }
+    dispose() {
+        _(this.watches)
+            .keys()
+            .each((name) => this.end(name));
+    }
+    static get killSwitchDir() {
+        return path.join(os.tmpdir(), process.env.SUDO_USER || process.env.USER || process.env.USERNAME || "", "KillSwitches");
+    }
+    static makeKillSwitchFileName(name) {
+        return path.join(CancellationService.killSwitchDir, name);
+    }
+}
+yok_1.injector.register("cancellation", CancellationService);

package/lib/common/services/commands-service.js

@@ -0,0 +1,268 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandsService = void 0;
+const jaroWinklerDistance = require("../vendor/jaro-winkler_distance");
+const helpers = require("../helpers");
+const os_1 = require("os");
+const _ = require("lodash");
+const yok_1 = require("../yok");
+class CommandArgumentsValidationHelper {
+    constructor(isValid, _remainingArguments) {
+        this.isValid = isValid;
+        this.remainingArguments = _remainingArguments.slice();
+    }
+}
+class CommandsService {
+    get currentCommandData() {
+        return _.last(this.commands);
+    }
+    constructor($errors, $hooksService, $injector, $logger, $options, $staticConfig, $extensibilityService, $optionsTracker) {
+        this.$errors = $errors;
+        this.$hooksService = $hooksService;
+        this.$injector = $injector;
+        this.$logger = $logger;
+        this.$options = $options;
+        this.$staticConfig = $staticConfig;
+        this.$extensibilityService = $extensibilityService;
+        this.$optionsTracker = $optionsTracker;
+        this.commands = [];
+    }
+    allCommands(opts) {
+        const commands = this.$injector.getRegisteredCommandsNames(opts.includeDevCommands);
+        return _.reject(commands, (command) => _.includes(command, "|"));
+    }
+    executeCommandUnchecked(commandName, commandArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.commands.push({ commandName, commandArguments });
+            const command = this.$injector.resolveCommand(commandName);
+            if (command) {
+                if (!this.$staticConfig.disableAnalytics &&
+                    !command.disableAnalytics &&
+                    !this.$options.disableAnalytics) {
+                    const analyticsService = this.$injector.resolve("analyticsService");
+                    yield analyticsService.checkConsent();
+                    const beautifiedCommandName = this.beautifyCommandName(commandName).replace(/\|/g, " ");
+                    const googleAnalyticsPageData = {
+                        googleAnalyticsDataType: "pageview",
+                        path: beautifiedCommandName,
+                        title: beautifiedCommandName,
+                    };
+                    yield analyticsService.trackInGoogleAnalytics(googleAnalyticsPageData);
+                    yield this.$optionsTracker.trackOptions(this.$options);
+                }
+                const shouldExecuteHooks = !this.$staticConfig.disableCommandHooks &&
+                    (command.enableHooks === undefined || command.enableHooks === true);
+                if (shouldExecuteHooks) {
+                    const hierarchicalCommandName = this.$injector.buildHierarchicalCommand(commandName, commandArguments);
+                    if (hierarchicalCommandName) {
+                        commandName = helpers.stringReplaceAll(hierarchicalCommandName.commandName, "|*", "-");
+                        commandName = helpers.stringReplaceAll(commandName, "|", "-");
+                    }
+                    yield this.$hooksService.executeBeforeHooks(commandName);
+                }
+                yield command.execute(commandArguments);
+                if (command.postCommandAction) {
+                    yield command.postCommandAction(commandArguments);
+                }
+                if (shouldExecuteHooks) {
+                    yield this.$hooksService.executeAfterHooks(commandName);
+                }
+                this.commands.pop();
+                return true;
+            }
+            this.commands.pop();
+            return false;
+        });
+    }
+    printHelpSuggestion(commandName) {
+        const command = commandName
+            ? helpers.stringReplaceAll(this.beautifyCommandName(commandName), "|", " ") + " "
+            : "";
+        const commandHelp = `ns ${command}--help`;
+        this.$logger.printMarkdown(`__Run \`${commandHelp}\` for more information.__`);
+        return;
+    }
+    executeCommandAction(commandName, commandArguments, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$errors.beginCommand(() => action.apply(this, [commandName, commandArguments]), () => this.printHelpSuggestion(commandName));
+        });
+    }
+    tryExecuteCommandAction(commandName, commandArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const command = this.$injector.resolveCommand(commandName);
+            if (!command || !command.isHierarchicalCommand) {
+                const dashedOptions = command ? command.dashedOptions : null;
+                this.$options.validateOptions(dashedOptions);
+            }
+            return this.canExecuteCommand(commandName, commandArguments);
+        });
+    }
+    tryExecuteCommand(commandName, commandArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const canExecuteResult = yield this.executeCommandAction(commandName, commandArguments, this.tryExecuteCommandAction);
+            const canExecute = typeof canExecuteResult === "object"
+                ? canExecuteResult.canExecute
+                : canExecuteResult;
+            if (canExecute) {
+                yield this.executeCommandAction(commandName, commandArguments, this.executeCommandUnchecked);
+            }
+            else {
+                const command = this.$injector.resolveCommand(commandName);
+                if (command) {
+                    let commandWithArgs = commandName;
+                    if (commandArguments && commandArguments.length) {
+                        commandWithArgs += ` ${commandArguments.join(" ")}`;
+                    }
+                    this.$logger.error(`Command '${commandWithArgs}' cannot be executed.`);
+                    yield this.printHelpSuggestion(commandName);
+                }
+            }
+        });
+    }
+    canExecuteCommand(commandName, commandArguments, isDynamicCommand) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const command = this.$injector.resolveCommand(commandName);
+            const beautifiedName = helpers.stringReplaceAll(commandName, "|", " ");
+            if (command) {
+                if (command.isDisabled) {
+                    this.$errors.fail("This command is not applicable to your environment.");
+                }
+                if (command.canExecute) {
+                    return yield command.canExecute(commandArguments);
+                }
+                if (yield this.$injector.isValidHierarchicalCommand(commandName, commandArguments)) {
+                    return true;
+                }
+                if (yield this.validateCommandArguments(command, commandArguments)) {
+                    return true;
+                }
+                this.$errors.fail(`Unable to execute command '${beautifiedName}'.`);
+                return false;
+            }
+            const commandInfo = {
+                inputStrings: [commandName, ...commandArguments],
+                commandDelimiter: "|",
+                defaultCommandDelimiter: "|*",
+            };
+            const extensionData = yield this.$extensibilityService.getExtensionNameWhereCommandIsRegistered(commandInfo);
+            if (extensionData) {
+                this.$logger.warn(extensionData.installationMessage);
+            }
+            else {
+                this.$logger.error("Unknown command '%s'.", beautifiedName);
+                yield this.printHelpSuggestion();
+                this.tryMatchCommand(commandName);
+            }
+            return false;
+        });
+    }
+    validateMandatoryParams(commandArguments, mandatoryParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const commandArgsHelper = new CommandArgumentsValidationHelper(true, commandArguments);
+            if (mandatoryParams.length > 0) {
+                if (mandatoryParams.length > commandArguments.length) {
+                    const customErrorMessages = _.map(mandatoryParams, (mp) => mp.errorMessage);
+                    customErrorMessages.splice(0, 0, "You need to provide all the required parameters.");
+                    this.$errors.failWithHelp(customErrorMessages.join(os_1.EOL));
+                }
+                for (let mandatoryParamIndex = 0; mandatoryParamIndex < mandatoryParams.length; ++mandatoryParamIndex) {
+                    const mandatoryParam = mandatoryParams[mandatoryParamIndex];
+                    let argument = null;
+                    for (let remainingArgsIndex = 0; remainingArgsIndex < commandArgsHelper.remainingArguments.length; ++remainingArgsIndex) {
+                        const c = commandArgsHelper.remainingArguments[remainingArgsIndex];
+                        if (yield mandatoryParam.validate(c)) {
+                            argument = c;
+                            break;
+                        }
+                    }
+                    if (argument) {
+                        helpers.remove(commandArgsHelper.remainingArguments, (arg) => arg === argument);
+                    }
+                    else {
+                        this.$errors.failWithHelp("Missing mandatory parameter.");
+                    }
+                }
+            }
+            return commandArgsHelper;
+        });
+    }
+    validateCommandArguments(command, commandArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mandatoryParams = _.filter(command.allowedParameters, (param) => param.mandatory);
+            const commandArgsHelper = yield this.validateMandatoryParams(commandArguments, mandatoryParams);
+            if (!commandArgsHelper.isValid) {
+                return false;
+            }
+            if (!command.allowedParameters || command.allowedParameters.length === 0) {
+                if (commandArguments.length > 0) {
+                    this.$errors.failWithHelp("This command doesn't accept parameters.");
+                }
+            }
+            else {
+                const unverifiedAllowedParams = command.allowedParameters.filter((param) => !param.mandatory);
+                for (let remainingArgsIndex = 0; remainingArgsIndex < commandArgsHelper.remainingArguments.length; ++remainingArgsIndex) {
+                    const argument = commandArgsHelper.remainingArguments[remainingArgsIndex];
+                    let parameter = null;
+                    for (let unverifiedIndex = 0; unverifiedIndex < unverifiedAllowedParams.length; ++unverifiedIndex) {
+                        const c = unverifiedAllowedParams[unverifiedIndex];
+                        if (yield c.validate(argument)) {
+                            parameter = c;
+                            break;
+                        }
+                    }
+                    if (parameter) {
+                        const index = unverifiedAllowedParams.indexOf(parameter);
+                        unverifiedAllowedParams.splice(index, 1);
+                    }
+                    else {
+                        this.$errors.failWithHelp(`The parameter ${argument} is not valid for this command.`);
+                    }
+                }
+            }
+            return true;
+        });
+    }
+    tryMatchCommand(commandName) {
+        const allCommands = this.allCommands({ includeDevCommands: false });
+        let similarCommands = [];
+        _.each(allCommands, (command) => {
+            if (!this.$injector.isDefaultCommand(command)) {
+                command = helpers.stringReplaceAll(command, "|", " ");
+                const distance = jaroWinklerDistance(commandName, command);
+                if (commandName.length > 3 && command.indexOf(commandName) !== -1) {
+                    similarCommands.push({ rating: 1, name: command });
+                }
+                else if (distance >= 0.65) {
+                    similarCommands.push({ rating: distance, name: command });
+                }
+            }
+        });
+        similarCommands = _.sortBy(similarCommands, (command) => {
+            return -command.rating;
+        }).slice(0, 5);
+        if (similarCommands.length > 0) {
+            const message = ["Did you mean?"];
+            _.each(similarCommands, (command) => {
+                message.push("\t" + command.name);
+            });
+            this.$logger.fatal(message.join("\n"));
+        }
+    }
+    beautifyCommandName(commandName) {
+        if (commandName.indexOf("*") > 0) {
+            return commandName.substring(0, commandName.indexOf("|"));
+        }
+        return commandName;
+    }
+}
+exports.CommandsService = CommandsService;
+yok_1.injector.register("commandsService", CommandsService);