nativescript 8.9.0-dev.2 → 8.9.0-dev.3

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

@@ -1,13 +1,4 @@
 "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.HelpService = void 0;
 const path = require("path");
@@ -44,155 +35,134 @@ class HelpService {
         this.pathToHtmlPages = this.$staticConfig.HTML_PAGES_DIR;
         this.pathToManPages = this.$staticConfig.MAN_PAGES_DIR;
     }
-    openHelpForCommandInBrowser(commandData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { commandName } = commandData;
-            const htmlPage = (yield this.convertCommandNameToFileName(commandData)) +
-                HelpService.HTML_FILE_EXTENSION;
-            this.$logger.trace("Opening help for command '%s'. FileName is '%s'.", commandName, htmlPage);
-            this.$fs.ensureDirectoryExists(this.pathToHtmlPages);
+    async openHelpForCommandInBrowser(commandData) {
+        const { commandName } = commandData;
+        const htmlPage = (await this.convertCommandNameToFileName(commandData)) +
+            HelpService.HTML_FILE_EXTENSION;
+        this.$logger.trace("Opening help for command '%s'. FileName is '%s'.", commandName, htmlPage);
+        this.$fs.ensureDirectoryExists(this.pathToHtmlPages);
+        if (!this.tryOpeningSelectedPage(htmlPage)) {
+            this.$logger.trace("Required HTML file '%s' is missing. Let's try generating HTML files and see if we'll find it.", htmlPage);
+            await this.generateHtmlPages();
             if (!this.tryOpeningSelectedPage(htmlPage)) {
-                // HTML pages may have been skipped on post-install, lets generate them.
-                this.$logger.trace("Required HTML file '%s' is missing. Let's try generating HTML files and see if we'll find it.", htmlPage);
-                yield this.generateHtmlPages();
-                if (!this.tryOpeningSelectedPage(htmlPage)) {
-                    this.$errors.fail("Unable to find help for '%s'", commandName);
-                }
-            }
-        });
-    }
-    generateHtmlPages() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mdFiles = this.$fs.enumerateFilesInDirectorySync(this.pathToManPages);
-            const basicHtmlPage = this.$fs.readText(this.pathToBasicPage);
-            yield Promise.all(_.map(mdFiles, (markdownFile) => {
-                const htmlPageGenerationData = {
-                    basicHtmlPage,
-                    pathToMdFile: markdownFile,
-                    pathToMdPages: this.pathToManPages,
-                    pathToHtmlPages: this.pathToHtmlPages,
-                };
-                return this.createHtmlPage(htmlPageGenerationData);
-            }));
-            const installedExtensionsData = this.$extensibilityService.getInstalledExtensionsData();
-            const basicHtmlPageForExtensions = this.$fs.readText(this.pathToBasicPageForExtensions);
-            for (const extensionData of installedExtensionsData) {
-                const docsDir = extensionData.docs;
-                if (docsDir) {
-                    this.$logger.trace(`Start generation of html help content for extension ${extensionData.extensionName}`);
-                    if (!this.$fs.exists(docsDir)) {
-                        this.$logger.warn(`Unable to generate html help pages for extension ${extensionData.extensionName} as the docs directory ${docsDir} does not exist.`);
-                        continue;
-                    }
-                    const htmlDirFullPath = HelpService.getHtmlDirFullPath(docsDir);
-                    this.$fs.ensureDirectoryExists(htmlDirFullPath);
-                    const extensionMdFiles = this.$fs.enumerateFilesInDirectorySync(docsDir);
-                    try {
-                        yield Promise.all(_.map(extensionMdFiles, (markdownFile) => {
-                            const htmlPageGenerationData = {
-                                basicHtmlPage: basicHtmlPageForExtensions,
-                                pathToMdFile: markdownFile,
-                                pathToMdPages: docsDir,
-                                pathToHtmlPages: htmlDirFullPath,
-                                extensionName: extensionData.extensionName,
-                            };
-                            return this.createHtmlPage(htmlPageGenerationData);
-                        }));
-                    }
-                    catch (err) {
-                        this.$logger.warn(`Unable to generate html help for extension ${extensionData.extensionName}. Error is: ${err.message}`);
-                    }
-                    this.$logger.trace(`Finished generation of html help content for extension ${extensionData.extensionName}`);
-                }
-            }
-            this.$logger.trace("Finished generating HTML files.");
-        });
-    }
-    showCommandLineHelp(commandData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const help = yield this.getCommandLineHelpForCommand(commandData);
-            this.$logger.printMarkdown(help);
-        });
-    }
-    /**
-     * Gets the help content for a specific command that should be shown on the terminal.
-     * @param {string} commandName Name of the command for which to read the help.
-     * @returns {Promise<string>} Help content of the command parsed with all terminal rules applied (stripped content that should be shown only for html help).
-     */
-    getCommandLineHelpForCommand(commandData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const helpText = yield this.readMdFileForCommand(commandData);
-            const commandLineHelp = (yield this.$microTemplateService.parseContent(helpText, { isHtml: false }))
-                .replace(/&nbsp;/g, " ")
-                .replace(HelpService.MARKDOWN_LINK_REGEX, "$1")
-                .replace(HelpService.SPAN_REGEX, (matchingSubstring, textBeforeSpan, textInsideSpan, index, fullString) => {
-                return textBeforeSpan + textInsideSpan.replace(this.newLineRegex, "");
-            })
-                .replace(HelpService.NEW_LINE_REGEX, os_1.EOL);
-            return commandLineHelp;
-        });
-    }
-    // This method should return Promise in order to generate all html pages simultaneously.
-    createHtmlPage(htmlPageGenerationData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { basicHtmlPage, pathToMdFile, pathToMdPages, pathToHtmlPages, extensionName, } = htmlPageGenerationData;
-            const mdFileName = path.basename(pathToMdFile);
-            const htmlFileName = mdFileName.replace(HelpService.MARKDOWN_FILE_EXTENSION, HelpService.HTML_FILE_EXTENSION);
-            this.$logger.trace("Generating '%s' help topic.", htmlFileName);
-            const helpText = this.$fs.readText(pathToMdFile);
-            const outputText = yield this.$microTemplateService.parseContent(helpText, {
-                isHtml: true,
-            });
-            const htmlText = (0, marked_1.marked)(outputText);
-            const filePath = pathToMdFile
-                .replace(path.basename(pathToMdPages), path.basename(pathToHtmlPages))
-                .replace(mdFileName, htmlFileName);
-            this.$logger.trace("HTML file path for '%s' man page is: '%s'.", mdFileName, filePath);
-            let outputHtml = basicHtmlPage
-                .replace(HelpService.MAN_PAGE_NAME_REGEX, mdFileName.replace(HelpService.MARKDOWN_FILE_EXTENSION, ""))
-                .replace(HelpService.HTML_COMMAND_HELP_REGEX, htmlText)
-                .replace(HelpService.RELATIVE_PATH_TO_STYLES_CSS_REGEX, path.relative(path.dirname(filePath), this.pathToStylesCss))
-                .replace(HelpService.RELATIVE_PATH_TO_IMAGES_REGEX, path.relative(path.dirname(filePath), this.pathToImages))
-                .replace(HelpService.RELATIVE_PATH_TO_INDEX_REGEX, path.relative(path.dirname(filePath), this.pathToIndexHtml));
-            if (extensionName) {
-                outputHtml = outputHtml.replace(HelpService.EXTENSION_NAME_REGEX, extensionName);
+                this.$errors.fail("Unable to find help for '%s'", commandName);
             }
-            this.$fs.writeFile(filePath, outputHtml);
-            this.$logger.trace("Finished writing file '%s'.", filePath);
-        });
-    }
-    convertCommandNameToFileName(commandData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let { commandName } = commandData;
-            const defaultCommandMatch = commandName && commandName.match(/([\w-]+?)\|\*/);
-            if (defaultCommandMatch) {
-                this.$logger.trace("Default command found. Replace current command name '%s' with '%s'.", commandName, defaultCommandMatch[1]);
-                commandName = defaultCommandMatch[1];
-            }
-            const availableCommands = this.$injector
-                .getRegisteredCommandsNames(true)
-                .sort();
-            this.$logger.trace("List of registered commands: %s", availableCommands.join(", "));
-            if (commandName && !_.includes(availableCommands, commandName)) {
-                yield this.throwMissingCommandError(commandData);
-            }
-            return (commandName && commandName.replace(/\|/g, "-")) || "start";
-        });
+        }
     }
-    throwMissingCommandError(commandData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const commandName = commandData.commandName;
-            const commandInfo = {
-                inputStrings: [commandName, ...commandData.commandArguments],
-                commandDelimiter: "|" /* CommandsDelimiters.HierarchicalCommand */,
-                defaultCommandDelimiter: "|*" /* CommandsDelimiters.DefaultHierarchicalCommand */,
+    async generateHtmlPages() {
+        const mdFiles = this.$fs.enumerateFilesInDirectorySync(this.pathToManPages);
+        const basicHtmlPage = this.$fs.readText(this.pathToBasicPage);
+        await Promise.all(_.map(mdFiles, (markdownFile) => {
+            const htmlPageGenerationData = {
+                basicHtmlPage,
+                pathToMdFile: markdownFile,
+                pathToMdPages: this.pathToManPages,
+                pathToHtmlPages: this.pathToHtmlPages,
             };
-            const extensionData = yield this.$extensibilityService.getExtensionNameWhereCommandIsRegistered(commandInfo);
-            if (extensionData) {
-                this.$errors.fail(extensionData.installationMessage);
+            return this.createHtmlPage(htmlPageGenerationData);
+        }));
+        const installedExtensionsData = this.$extensibilityService.getInstalledExtensionsData();
+        const basicHtmlPageForExtensions = this.$fs.readText(this.pathToBasicPageForExtensions);
+        for (const extensionData of installedExtensionsData) {
+            const docsDir = extensionData.docs;
+            if (docsDir) {
+                this.$logger.trace(`Start generation of html help content for extension ${extensionData.extensionName}`);
+                if (!this.$fs.exists(docsDir)) {
+                    this.$logger.warn(`Unable to generate html help pages for extension ${extensionData.extensionName} as the docs directory ${docsDir} does not exist.`);
+                    continue;
+                }
+                const htmlDirFullPath = HelpService.getHtmlDirFullPath(docsDir);
+                this.$fs.ensureDirectoryExists(htmlDirFullPath);
+                const extensionMdFiles = this.$fs.enumerateFilesInDirectorySync(docsDir);
+                try {
+                    await Promise.all(_.map(extensionMdFiles, (markdownFile) => {
+                        const htmlPageGenerationData = {
+                            basicHtmlPage: basicHtmlPageForExtensions,
+                            pathToMdFile: markdownFile,
+                            pathToMdPages: docsDir,
+                            pathToHtmlPages: htmlDirFullPath,
+                            extensionName: extensionData.extensionName,
+                        };
+                        return this.createHtmlPage(htmlPageGenerationData);
+                    }));
+                }
+                catch (err) {
+                    this.$logger.warn(`Unable to generate html help for extension ${extensionData.extensionName}. Error is: ${err.message}`);
+                }
+                this.$logger.trace(`Finished generation of html help content for extension ${extensionData.extensionName}`);
             }
-            this.$errors.fail("Unknown command '%s'. Try '$ %s help' for a full list of supported commands.", commandName, this.$staticConfig.CLIENT_NAME.toLowerCase());
+        }
+        this.$logger.trace("Finished generating HTML files.");
+    }
+    async showCommandLineHelp(commandData) {
+        const help = await this.getCommandLineHelpForCommand(commandData);
+        this.$logger.printMarkdown(help);
+    }
+    async getCommandLineHelpForCommand(commandData) {
+        const helpText = await this.readMdFileForCommand(commandData);
+        const commandLineHelp = (await this.$microTemplateService.parseContent(helpText, { isHtml: false }))
+            .replace(/&nbsp;/g, " ")
+            .replace(HelpService.MARKDOWN_LINK_REGEX, "$1")
+            .replace(HelpService.SPAN_REGEX, (matchingSubstring, textBeforeSpan, textInsideSpan, index, fullString) => {
+            return textBeforeSpan + textInsideSpan.replace(this.newLineRegex, "");
+        })
+            .replace(HelpService.NEW_LINE_REGEX, os_1.EOL);
+        return commandLineHelp;
+    }
+    async createHtmlPage(htmlPageGenerationData) {
+        const { basicHtmlPage, pathToMdFile, pathToMdPages, pathToHtmlPages, extensionName, } = htmlPageGenerationData;
+        const mdFileName = path.basename(pathToMdFile);
+        const htmlFileName = mdFileName.replace(HelpService.MARKDOWN_FILE_EXTENSION, HelpService.HTML_FILE_EXTENSION);
+        this.$logger.trace("Generating '%s' help topic.", htmlFileName);
+        const helpText = this.$fs.readText(pathToMdFile);
+        const outputText = await this.$microTemplateService.parseContent(helpText, {
+            isHtml: true,
         });
+        const htmlText = await (0, marked_1.marked)(outputText);
+        const filePath = pathToMdFile
+            .replace(path.basename(pathToMdPages), path.basename(pathToHtmlPages))
+            .replace(mdFileName, htmlFileName);
+        this.$logger.trace("HTML file path for '%s' man page is: '%s'.", mdFileName, filePath);
+        let outputHtml = basicHtmlPage
+            .replace(HelpService.MAN_PAGE_NAME_REGEX, mdFileName.replace(HelpService.MARKDOWN_FILE_EXTENSION, ""))
+            .replace(HelpService.HTML_COMMAND_HELP_REGEX, htmlText)
+            .replace(HelpService.RELATIVE_PATH_TO_STYLES_CSS_REGEX, path.relative(path.dirname(filePath), this.pathToStylesCss))
+            .replace(HelpService.RELATIVE_PATH_TO_IMAGES_REGEX, path.relative(path.dirname(filePath), this.pathToImages))
+            .replace(HelpService.RELATIVE_PATH_TO_INDEX_REGEX, path.relative(path.dirname(filePath), this.pathToIndexHtml));
+        if (extensionName) {
+            outputHtml = outputHtml.replace(HelpService.EXTENSION_NAME_REGEX, extensionName);
+        }
+        this.$fs.writeFile(filePath, outputHtml);
+        this.$logger.trace("Finished writing file '%s'.", filePath);
+    }
+    async convertCommandNameToFileName(commandData) {
+        let { commandName } = commandData;
+        const defaultCommandMatch = commandName && commandName.match(/([\w-]+?)\|\*/);
+        if (defaultCommandMatch) {
+            this.$logger.trace("Default command found. Replace current command name '%s' with '%s'.", commandName, defaultCommandMatch[1]);
+            commandName = defaultCommandMatch[1];
+        }
+        const availableCommands = this.$injector
+            .getRegisteredCommandsNames(true)
+            .sort();
+        this.$logger.trace("List of registered commands: %s", availableCommands.join(", "));
+        if (commandName && !_.includes(availableCommands, commandName)) {
+            await this.throwMissingCommandError(commandData);
+        }
+        return (commandName && commandName.replace(/\|/g, "-")) || "start";
+    }
+    async throwMissingCommandError(commandData) {
+        const commandName = commandData.commandName;
+        const commandInfo = {
+            inputStrings: [commandName, ...commandData.commandArguments],
+            commandDelimiter: "|",
+            defaultCommandDelimiter: "|*",
+        };
+        const extensionData = await this.$extensibilityService.getExtensionNameWhereCommandIsRegistered(commandInfo);
+        if (extensionData) {
+            this.$errors.fail(extensionData.installationMessage);
+        }
+        this.$errors.fail("Unknown command '%s'. Try '$ %s help' for a full list of supported commands.", commandName, this.$staticConfig.CLIENT_NAME.toLowerCase());
     }
     static getHtmlDirFullPath(docsDir) {
         return path.join(path.dirname(docsDir), "html");
@@ -231,19 +201,18 @@ class HelpService {
         this.$logger.trace("Unable to find file: '%s'", htmlPage);
         return false;
     }
-    readMdFileForCommand(commandData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mdFileName = (yield this.convertCommandNameToFileName(commandData)) +
-                HelpService.MARKDOWN_FILE_EXTENSION;
-            this.$logger.trace("Reading help for command '%s'. FileName is '%s'.", commandData.commandName, mdFileName);
-            const markdownFile = this.getHelpFile(mdFileName, this.pathToManPages);
-            if (markdownFile) {
-                return this.$fs.readText(markdownFile);
-            }
-            yield this.throwMissingCommandError(commandData);
-        });
+    async readMdFileForCommand(commandData) {
+        const mdFileName = (await this.convertCommandNameToFileName(commandData)) +
+            HelpService.MARKDOWN_FILE_EXTENSION;
+        this.$logger.trace("Reading help for command '%s'. FileName is '%s'.", commandData.commandName, mdFileName);
+        const markdownFile = this.getHelpFile(mdFileName, this.pathToManPages);
+        if (markdownFile) {
+            return this.$fs.readText(markdownFile);
+        }
+        await this.throwMissingCommandError(commandData);
     }
 }
+exports.HelpService = HelpService;
 HelpService.MARKDOWN_FILE_EXTENSION = ".md";
 HelpService.HTML_FILE_EXTENSION = ".html";
 HelpService.MAN_PAGE_NAME_REGEX = /@MAN_PAGE_NAME@/g;
@@ -254,7 +223,5 @@ HelpService.RELATIVE_PATH_TO_INDEX_REGEX = /@RELATIVE_PATH_TO_INDEX@/g;
 HelpService.EXTENSION_NAME_REGEX = /@EXTENSION_NAME@/g;
 HelpService.MARKDOWN_LINK_REGEX = /\[([\w \-\`\<\>\*\:\\]+?)\]\([\s\S]+?\)/g;
 HelpService.SPAN_REGEX = /([\s\S]*?)(?:\r?\n)?<span.*?>([\s\S]*?)<\/span>(?:\r?\n)*/g;
-HelpService.NEW_LINE_REGEX = /<\/?\s*?br\s*?\/?>/g; // <br>, <br > <br/> <br />
-exports.HelpService = HelpService;
+HelpService.NEW_LINE_REGEX = /<\/?\s*?br\s*?\/?>/g;
 yok_1.injector.register("helpService", HelpService);
-//# sourceMappingURL=help-service.js.map

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

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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.HooksService = void 0;
 const path = require("path");
@@ -61,7 +52,6 @@ class HooksService {
         }
     }
     static formatHookName(commandName) {
-        // Remove everything after | (including the pipe)
         return commandName.replace(/\|[\s\S]*$/, "");
     }
     executeBeforeHooks(commandName, hookArguments) {
@@ -74,123 +64,111 @@ class HooksService {
         const traceMessage = `AfterHookName for command ${commandName} is ${afterHookName}`;
         return this.executeHooks(afterHookName, traceMessage, hookArguments);
     }
-    executeHooks(hookName, traceMessage, hookArguments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.$config.DISABLE_HOOKS || !this.$options.hooks) {
-                return;
+    async executeHooks(hookName, traceMessage, hookArguments) {
+        if (this.$config.DISABLE_HOOKS || !this.$options.hooks) {
+            return;
+        }
+        const hookArgs = hookArguments && hookArguments[this.hookArgsName];
+        let projectDir = hookArgs && hookArgs.projectDir;
+        if (!projectDir && hookArgs) {
+            const candidate = (0, helpers_1.getValueFromNestedObject)(hookArgs, "projectDir");
+            projectDir = candidate && candidate.projectDir;
+        }
+        this.$logger.trace(`Project dir from hooksArgs is: ${projectDir}.`);
+        this.initialize(projectDir);
+        this.$logger.trace(traceMessage);
+        const results = [];
+        try {
+            for (const hooksDirectory of this.hooksDirectories) {
+                results.push(await this.executeHooksInDirectory(hooksDirectory, hookName, hookArguments));
             }
-            const hookArgs = hookArguments && hookArguments[this.hookArgsName];
-            let projectDir = hookArgs && hookArgs.projectDir;
-            if (!projectDir && hookArgs) {
-                const candidate = (0, helpers_1.getValueFromNestedObject)(hookArgs, "projectDir");
-                projectDir = candidate && candidate.projectDir;
+            const customHooks = this.getCustomHooksByName(hookName);
+            for (const hook of customHooks) {
+                results.push(await this.executeHook(this.$projectHelper.projectDir, hookName, hook, hookArguments));
             }
-            this.$logger.trace(`Project dir from hooksArgs is: ${projectDir}.`);
-            this.initialize(projectDir);
-            this.$logger.trace(traceMessage);
-            const results = [];
-            try {
-                for (const hooksDirectory of this.hooksDirectories) {
-                    results.push(yield this.executeHooksInDirectory(hooksDirectory, hookName, hookArguments));
-                }
-                const customHooks = this.getCustomHooksByName(hookName);
-                for (const hook of customHooks) {
-                    results.push(yield this.executeHook(this.$projectHelper.projectDir, hookName, hook, hookArguments));
-                }
+        }
+        catch (err) {
+            this.$logger.trace(`Failed during hook execution ${hookName}.`);
+            this.$errors.fail(err.message || err);
+        }
+        return _.flatten(results);
+    }
+    async executeHook(directoryPath, hookName, hook, hookArguments) {
+        hookArguments = hookArguments || {};
+        let result;
+        const relativePath = path.relative(directoryPath, hook.fullPath);
+        const trackId = relativePath.replace(new RegExp("\\" + path.sep, "g"), constants_1.AnalyticsEventLabelDelimiter);
+        let command = this.getSheBangInterpreter(hook);
+        let inProc = false;
+        if (!command) {
+            command = hook.fullPath;
+            if (path.extname(hook.fullPath).toLowerCase() === ".js") {
+                command = process.argv[0];
+                inProc = this.shouldExecuteInProcess(this.$fs.readText(hook.fullPath));
             }
-            catch (err) {
-                this.$logger.trace(`Failed during hook execution ${hookName}.`);
-                this.$errors.fail(err.message || err);
+        }
+        const startTime = this.$performanceService.now();
+        if (inProc) {
+            this.$logger.trace("Executing %s hook at location %s in-process", hookName, hook.fullPath);
+            const hookEntryPoint = require(hook.fullPath);
+            this.$logger.trace(`Validating ${hookName} arguments.`);
+            const invalidArguments = this.validateHookArguments(hookEntryPoint, hook.fullPath);
+            if (invalidArguments.length) {
+                this.$logger.warn(`${hook.fullPath} will NOT be executed because it has invalid arguments - ${color_1.color.grey(invalidArguments.join(", "))}.`);
+                return;
             }
-            return _.flatten(results);
-        });
-    }
-    executeHook(directoryPath, hookName, hook, hookArguments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            hookArguments = hookArguments || {};
-            let result;
-            const relativePath = path.relative(directoryPath, hook.fullPath);
-            const trackId = relativePath.replace(new RegExp("\\" + path.sep, "g"), constants_1.AnalyticsEventLabelDelimiter);
-            let command = this.getSheBangInterpreter(hook);
-            let inProc = false;
-            if (!command) {
-                command = hook.fullPath;
-                if (path.extname(hook.fullPath).toLowerCase() === ".js") {
-                    command = process.argv[0];
-                    inProc = this.shouldExecuteInProcess(this.$fs.readText(hook.fullPath));
-                }
+            const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
+            if (projectDataHookArg) {
+                hookArguments["projectData"] = hookArguments["$projectData"] = projectDataHookArg;
             }
-            const startTime = this.$performanceService.now();
-            if (inProc) {
-                this.$logger.trace("Executing %s hook at location %s in-process", hookName, hook.fullPath);
-                const hookEntryPoint = require(hook.fullPath);
-                this.$logger.trace(`Validating ${hookName} arguments.`);
-                const invalidArguments = this.validateHookArguments(hookEntryPoint, hook.fullPath);
-                if (invalidArguments.length) {
-                    this.$logger.warn(`${hook.fullPath} will NOT be executed because it has invalid arguments - ${color_1.color.grey(invalidArguments.join(", "))}.`);
-                    return;
+            const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
+            if (maybePromise) {
+                this.$logger.trace("Hook promises to signal completion");
+                try {
+                    result = await maybePromise;
                 }
-                // HACK for backwards compatibility:
-                // In case $projectData wasn't resolved by the time we got here (most likely we got here without running a command but through a service directly)
-                // then it is probably passed as a hookArg
-                // if that is the case then pass it directly to the hook instead of trying to resolve $projectData via injector
-                // This helps make hooks stateless
-                const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
-                if (projectDataHookArg) {
-                    hookArguments["projectData"] = hookArguments["$projectData"] = projectDataHookArg;
-                }
-                const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
-                if (maybePromise) {
-                    this.$logger.trace("Hook promises to signal completion");
-                    try {
-                        result = yield maybePromise;
+                catch (err) {
+                    if (err &&
+                        _.isBoolean(err.stopExecution) &&
+                        err.errorAsWarning === true) {
+                        this.$logger.warn(err.message || err);
                     }
-                    catch (err) {
-                        if (err &&
-                            _.isBoolean(err.stopExecution) &&
-                            err.errorAsWarning === true) {
-                            this.$logger.warn(err.message || err);
-                        }
-                        else {
-                            // Print the actual error with its callstack, so it is easy to find out which hooks is causing troubles.
-                            this.$logger.error(err);
-                            throw err || new Error(`Failed to execute hook: ${hook.fullPath}.`);
-                        }
+                    else {
+                        this.$logger.error(err);
+                        throw err || new Error(`Failed to execute hook: ${hook.fullPath}.`);
                     }
-                    this.$logger.trace("Hook completed");
                 }
+                this.$logger.trace("Hook completed");
             }
-            else {
-                const environment = this.prepareEnvironment(hook.fullPath);
-                this.$logger.trace("Executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
-                const output = yield this.$childProcess.spawnFromEvent(command, [hook.fullPath], "close", environment, { throwError: false });
-                result = output;
-                if (output.exitCode !== 0) {
-                    throw new Error(output.stdout + output.stderr);
-                }
-                this.$logger.trace("Finished executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
+        }
+        else {
+            const environment = this.prepareEnvironment(hook.fullPath);
+            this.$logger.trace("Executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
+            const output = await this.$childProcess.spawnFromEvent(command, [hook.fullPath], "close", environment, { throwError: false });
+            result = output;
+            if (output.exitCode !== 0) {
+                throw new Error(output.stdout + output.stderr);
             }
-            const endTime = this.$performanceService.now();
-            this.$performanceService.processExecutionData(trackId, startTime, endTime, [
-                hookArguments,
-            ]);
-            return result;
-        });
+            this.$logger.trace("Finished executing %s hook at location %s with environment ", hookName, hook.fullPath, environment);
+        }
+        const endTime = this.$performanceService.now();
+        this.$performanceService.processExecutionData(trackId, startTime, endTime, [
+            hookArguments,
+        ]);
+        return result;
     }
-    executeHooksInDirectory(directoryPath, hookName, hookArguments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            hookArguments = hookArguments || {};
-            const results = [];
-            const hooks = this.getHooksByName(directoryPath, hookName);
-            for (let i = 0; i < hooks.length; ++i) {
-                const hook = hooks[i];
-                const result = yield this.executeHook(directoryPath, hookName, hook, hookArguments);
-                if (result) {
-                    results.push(result);
-                }
+    async executeHooksInDirectory(directoryPath, hookName, hookArguments) {
+        hookArguments = hookArguments || {};
+        const results = [];
+        const hooks = this.getHooksByName(directoryPath, hookName);
+        for (let i = 0; i < hooks.length; ++i) {
+            const hook = hooks[i];
+            const result = await this.executeHook(directoryPath, hookName, hook, hookArguments);
+            if (result) {
+                results.push(result);
             }
-            return results;
-        });
+        }
+        return results;
     }
     getCustomHooksByName(hookName) {
         const hooks = [];
@@ -258,7 +236,6 @@ class HooksService {
                 interpreter = sheBangMatch[1];
             }
             if (interpreter) {
-                // Likewise, make /usr/bin/bash work like "bash".
                 shMatch = interpreter.match(/bin\/((?:ba)?sh)$/);
             }
             if (shMatch) {
@@ -299,7 +276,6 @@ class HooksService {
     }
     validateHookArguments(hookConstructor, hookFullPath) {
         const invalidArguments = [];
-        // We need to annotate the hook in order to have the arguments of the constructor.
         (0, helpers_1.annotate)(hookConstructor);
         _.each(hookConstructor.$inject.args, (argument) => {
             try {
@@ -315,17 +291,13 @@ class HooksService {
         return invalidArguments;
     }
 }
+exports.HooksService = HooksService;
 HooksService.HOOKS_DIRECTORY_NAME = "hooks";
 __decorate([
     (0, decorators_1.memoize)({
         shouldCache() {
-            // only cache if we have hooks directories, the only case to
-            // not have hooks directories is when the project dir is
-            // not set yet, ie. when creating a project.
             return !!this.hooksDirectories.length;
         },
     })
 ], HooksService.prototype, "initialize", null);
-exports.HooksService = HooksService;
 yok_1.injector.register("hooksService", HooksService);
-//# sourceMappingURL=hooks-service.js.map