nativescript 8.9.0-dev.1 → 8.9.0-dev.2

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

@@ -1,4 +1,13 @@
 "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");
@@ -35,134 +44,155 @@ class HelpService {
         this.pathToHtmlPages = this.$staticConfig.HTML_PAGES_DIR;
         this.pathToManPages = this.$staticConfig.MAN_PAGES_DIR;
     }
-    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();
+    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);
             if (!this.tryOpeningSelectedPage(htmlPage)) {
-                this.$errors.fail("Unable to find help for '%s'", commandName);
+                // 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);
+                }
             }
-        }
+        });
     }
-    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,
-            };
-            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);
-                    }));
+    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}`);
                 }
-                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.");
-    }
-    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(/ /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,
+            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.$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 */,
+            };
+            const extensionData = yield 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());
         });
-        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");
@@ -201,18 +231,19 @@ class HelpService {
         this.$logger.trace("Unable to find file: '%s'", htmlPage);
         return false;
     }
-    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);
+    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);
+        });
     }
 }
-exports.HelpService = HelpService;
 HelpService.MARKDOWN_FILE_EXTENSION = ".md";
 HelpService.HTML_FILE_EXTENSION = ".html";
 HelpService.MAN_PAGE_NAME_REGEX = /@MAN_PAGE_NAME@/g;
@@ -223,5 +254,7 @@ 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;
+HelpService.NEW_LINE_REGEX = /<\/?\s*?br\s*?\/?>/g; // <br>, <br > <br/> <br />
+exports.HelpService = HelpService;
 yok_1.injector.register("helpService", HelpService);
+//# sourceMappingURL=help-service.js.map

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

@@ -5,6 +5,15 @@ 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");
@@ -52,6 +61,7 @@ class HooksService {
         }
     }
     static formatHookName(commandName) {
+        // Remove everything after | (including the pipe)
         return commandName.replace(/\|[\s\S]*$/, "");
     }
     executeBeforeHooks(commandName, hookArguments) {
@@ -64,111 +74,123 @@ class HooksService {
         const traceMessage = `AfterHookName for command ${commandName} is ${afterHookName}`;
         return this.executeHooks(afterHookName, traceMessage, hookArguments);
     }
-    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));
+    executeHooks(hookName, traceMessage, hookArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.$config.DISABLE_HOOKS || !this.$options.hooks) {
+                return;
             }
-            const customHooks = this.getCustomHooksByName(hookName);
-            for (const hook of customHooks) {
-                results.push(await this.executeHook(this.$projectHelper.projectDir, hookName, hook, 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;
             }
-        }
-        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));
+            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));
+                }
             }
-        }
-        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;
+            catch (err) {
+                this.$logger.trace(`Failed during hook execution ${hookName}.`);
+                this.$errors.fail(err.message || err);
             }
-            const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
-            if (projectDataHookArg) {
-                hookArguments["projectData"] = hookArguments["$projectData"] = projectDataHookArg;
+            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 maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
-            if (maybePromise) {
-                this.$logger.trace("Hook promises to signal completion");
-                try {
-                    result = await maybePromise;
+            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;
                 }
-                catch (err) {
-                    if (err &&
-                        _.isBoolean(err.stopExecution) &&
-                        err.errorAsWarning === true) {
-                        this.$logger.warn(err.message || err);
+                // 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;
                     }
-                    else {
-                        this.$logger.error(err);
-                        throw err || new Error(`Failed to execute hook: ${hook.fullPath}.`);
+                    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}.`);
+                        }
                     }
+                    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 = await this.$childProcess.spawnFromEvent(command, [hook.fullPath], "close", environment, { throwError: false });
-            result = output;
-            if (output.exitCode !== 0) {
-                throw new Error(output.stdout + output.stderr);
+            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);
             }
-            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;
+            const endTime = this.$performanceService.now();
+            this.$performanceService.processExecutionData(trackId, startTime, endTime, [
+                hookArguments,
+            ]);
+            return 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);
+    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);
+                }
             }
-        }
-        return results;
+            return results;
+        });
     }
     getCustomHooksByName(hookName) {
         const hooks = [];
@@ -236,6 +258,7 @@ class HooksService {
                 interpreter = sheBangMatch[1];
             }
             if (interpreter) {
+                // Likewise, make /usr/bin/bash work like "bash".
                 shMatch = interpreter.match(/bin\/((?:ba)?sh)$/);
             }
             if (shMatch) {
@@ -276,6 +299,7 @@ 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 {
@@ -291,13 +315,17 @@ 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