@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,252 @@
+"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");
+const os_1 = require("os");
+const marked_1 = require("marked");
+const yok_1 = require("../yok");
+const _ = require("lodash");
+class HelpService {
+    get newLineRegex() {
+        return /\r?\n/g;
+    }
+    get pathToStylesCss() {
+        return path.join(this.$staticConfig.HTML_COMMON_HELPERS_DIR, "styles.css");
+    }
+    get pathToBasicPage() {
+        return path.join(this.$staticConfig.HTML_COMMON_HELPERS_DIR, "basic-page.html");
+    }
+    get pathToBasicPageForExtensions() {
+        return path.join(this.$staticConfig.HTML_COMMON_HELPERS_DIR, "basic-extensions-page.html");
+    }
+    get pathToIndexHtml() {
+        return path.join(this.$staticConfig.HTML_PAGES_DIR, "index.html");
+    }
+    constructor($logger, $injector, $errors, $fs, $staticConfig, $extensibilityService, $microTemplateService, $opener) {
+        this.$logger = $logger;
+        this.$injector = $injector;
+        this.$errors = $errors;
+        this.$fs = $fs;
+        this.$staticConfig = $staticConfig;
+        this.$extensibilityService = $extensibilityService;
+        this.$microTemplateService = $microTemplateService;
+        this.$opener = $opener;
+        this.pathToImages = this.$staticConfig.HTML_CLI_HELPERS_DIR;
+        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);
+            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);
+                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);
+        });
+    }
+    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(/ /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;
+        });
+    }
+    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: "|",
+                defaultCommandDelimiter: "|*",
+            };
+            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());
+        });
+    }
+    static getHtmlDirFullPath(docsDir) {
+        return path.join(path.dirname(docsDir), "html");
+    }
+    getHelpFile(searchedFileName, dirToCheck, getFullPathAction) {
+        const fileList = this.$fs.enumerateFilesInDirectorySync(dirToCheck);
+        let fileToOpen = _.find(fileList, (file) => path.basename(file) === searchedFileName);
+        if (!fileToOpen) {
+            fileToOpen = this.getHelpFileFromExtensions(searchedFileName, getFullPathAction);
+        }
+        return fileToOpen;
+    }
+    getHelpFileFromExtensions(searchedFileName, getFullPathAction) {
+        const installedExtensionsData = this.$extensibilityService.getInstalledExtensionsData();
+        for (const extensionData of installedExtensionsData) {
+            const docsDir = extensionData.docs;
+            if (docsDir) {
+                const fullPath = getFullPathAction
+                    ? getFullPathAction(docsDir)
+                    : docsDir;
+                const fileToOpen = this.$fs.exists(fullPath) &&
+                    _.find(this.$fs.enumerateFilesInDirectorySync(fullPath), (file) => path.basename(file) === searchedFileName);
+                if (fileToOpen) {
+                    return fileToOpen;
+                }
+            }
+        }
+    }
+    tryOpeningSelectedPage(htmlPage) {
+        const pageToOpen = this.getHelpFile(htmlPage, this.pathToHtmlPages, HelpService.getHtmlDirFullPath);
+        if (pageToOpen) {
+            this.$logger.trace("Found page to open: '%s'", pageToOpen);
+            this.$opener.open(pageToOpen, "");
+            return true;
+        }
+        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);
+        });
+    }
+}
+HelpService.MARKDOWN_FILE_EXTENSION = ".md";
+HelpService.HTML_FILE_EXTENSION = ".html";
+HelpService.MAN_PAGE_NAME_REGEX = /@MAN_PAGE_NAME@/g;
+HelpService.HTML_COMMAND_HELP_REGEX = /@HTML_COMMAND_HELP@/g;
+HelpService.RELATIVE_PATH_TO_STYLES_CSS_REGEX = /@RELATIVE_PATH_TO_STYLES_CSS@/g;
+HelpService.RELATIVE_PATH_TO_IMAGES_REGEX = /@RELATIVE_PATH_TO_IMAGES@/g;
+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;
+exports.HelpService = HelpService;
+yok_1.injector.register("helpService", HelpService);

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

@@ -0,0 +1,318 @@
+"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.HooksService = void 0;
+const path = require("path");
+const util = require("util");
+const _ = require("lodash");
+const helpers_1 = require("../helpers");
+const constants_1 = require("../../constants");
+const yok_1 = require("../yok");
+const color_1 = require("../../color");
+const decorators_1 = require("../decorators");
+class Hook {
+    constructor(name, fullPath) {
+        this.name = name;
+        this.fullPath = fullPath;
+    }
+}
+class HooksService {
+    constructor($childProcess, $fs, $logger, $errors, $config, $staticConfig, $injector, $projectHelper, $options, $performanceService, $projectConfigService) {
+        this.$childProcess = $childProcess;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$errors = $errors;
+        this.$config = $config;
+        this.$staticConfig = $staticConfig;
+        this.$injector = $injector;
+        this.$projectHelper = $projectHelper;
+        this.$options = $options;
+        this.$performanceService = $performanceService;
+        this.$projectConfigService = $projectConfigService;
+    }
+    get hookArgsName() {
+        return "hookArgs";
+    }
+    initialize(projectDir) {
+        this.cachedHooks = {};
+        this.hooksDirectories = [];
+        projectDir = projectDir || this.$projectHelper.projectDir;
+        if (projectDir) {
+            this.hooksDirectories.push(path.join(projectDir, HooksService.HOOKS_DIRECTORY_NAME));
+        }
+        this.$logger.trace("Hooks directories: " + util.inspect(this.hooksDirectories));
+        const customHooks = this.$projectConfigService.getValue("hooks", []);
+        if (customHooks.length) {
+            this.$logger.trace("Custom hooks: " + util.inspect(customHooks));
+        }
+    }
+    static formatHookName(commandName) {
+        return commandName.replace(/\|[\s\S]*$/, "");
+    }
+    executeBeforeHooks(commandName, hookArguments) {
+        const beforeHookName = `before-${HooksService.formatHookName(commandName)}`;
+        const traceMessage = `BeforeHookName for command ${commandName} is ${beforeHookName}`;
+        return this.executeHooks(beforeHookName, traceMessage, hookArguments);
+    }
+    executeAfterHooks(commandName, hookArguments) {
+        const afterHookName = `after-${HooksService.formatHookName(commandName)}`;
+        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;
+            }
+            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(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.stack || err.message || err);
+            }
+            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 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 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);
+                        }
+                        else {
+                            this.$logger.error(err);
+                            throw err || new Error(`Failed to execute hook: ${hook.fullPath}.`);
+                        }
+                    }
+                    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);
+            }
+            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);
+                }
+            }
+            return results;
+        });
+    }
+    getCustomHooksByName(hookName) {
+        const hooks = [];
+        const customHooks = this.$projectConfigService.getValue("hooks", []);
+        for (const cHook of customHooks) {
+            if (cHook.type === hookName) {
+                const fullPath = path.join(this.$projectHelper.projectDir, cHook.script);
+                const isFile = this.$fs.getFsStats(fullPath).isFile();
+                if (isFile) {
+                    const fileNameParts = cHook.script.split("/");
+                    hooks.push(new Hook(this.getBaseFilename(fileNameParts[fileNameParts.length - 1]), fullPath));
+                }
+            }
+        }
+        return hooks;
+    }
+    getHooksByName(directoryPath, hookName) {
+        const allBaseHooks = this.getHooksInDirectory(directoryPath);
+        const baseHooks = _.filter(allBaseHooks, (hook) => hook.name.toLowerCase() === hookName.toLowerCase());
+        const moreHooks = this.getHooksInDirectory(path.join(directoryPath, hookName));
+        return baseHooks.concat(moreHooks);
+    }
+    getHooksInDirectory(directoryPath) {
+        if (!this.cachedHooks[directoryPath]) {
+            let hooks = [];
+            if (directoryPath &&
+                this.$fs.exists(directoryPath) &&
+                this.$fs.getFsStats(directoryPath).isDirectory()) {
+                const directoryContent = this.$fs.readDirectory(directoryPath);
+                const files = _.filter(directoryContent, (entry) => {
+                    const fullPath = path.join(directoryPath, entry);
+                    const isFile = this.$fs.getFsStats(fullPath).isFile();
+                    return isFile;
+                });
+                hooks = _.map(files, (file) => {
+                    const fullPath = path.join(directoryPath, file);
+                    return new Hook(this.getBaseFilename(file), fullPath);
+                });
+            }
+            this.cachedHooks[directoryPath] = hooks;
+        }
+        return this.cachedHooks[directoryPath];
+    }
+    prepareEnvironment(hookFullPath) {
+        const clientName = this.$staticConfig.CLIENT_NAME.toUpperCase();
+        const environment = {};
+        environment[util.format("%s-COMMANDLINE", clientName)] = process.argv.join(" ");
+        environment[util.format("%s-HOOK_FULL_PATH", clientName)] = hookFullPath;
+        environment[util.format("%s-VERSION", clientName)] = this.$staticConfig.version;
+        return {
+            cwd: this.$projectHelper.projectDir,
+            stdio: "inherit",
+            env: _.extend({}, process.env, environment),
+        };
+    }
+    getSheBangInterpreter(hook) {
+        let interpreter = null;
+        let shMatch = [];
+        const fileContent = this.$fs.readText(hook.fullPath);
+        if (fileContent) {
+            const sheBangMatch = fileContent
+                .split("\n")[0]
+                .match(/^#!(?:\/usr\/bin\/env )?([^\r\n]+)/m);
+            if (sheBangMatch) {
+                interpreter = sheBangMatch[1];
+            }
+            if (interpreter) {
+                shMatch = interpreter.match(/bin\/((?:ba)?sh)$/);
+            }
+            if (shMatch) {
+                interpreter = shMatch[1];
+            }
+        }
+        return interpreter;
+    }
+    getBaseFilename(fileName) {
+        return fileName.substr(0, fileName.length - path.extname(fileName).length);
+    }
+    shouldExecuteInProcess(scriptSource) {
+        try {
+            const esprima = require("esprima");
+            const ast = esprima.parse(scriptSource);
+            let inproc = false;
+            ast.body.forEach((statement) => {
+                if (statement.type !== "ExpressionStatement" ||
+                    statement.expression.type !== "AssignmentExpression") {
+                    return;
+                }
+                const left = statement.expression.left;
+                if (left.type === "MemberExpression" &&
+                    left.object &&
+                    left.object.type === "Identifier" &&
+                    left.object.name === "module" &&
+                    left.property &&
+                    left.property.type === "Identifier" &&
+                    left.property.name === "exports") {
+                    inproc = true;
+                }
+            });
+            return inproc;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    validateHookArguments(hookConstructor, hookFullPath) {
+        const invalidArguments = [];
+        (0, helpers_1.annotate)(hookConstructor);
+        _.each(hookConstructor.$inject.args, (argument) => {
+            try {
+                if (argument !== this.hookArgsName) {
+                    this.$injector.resolve(argument);
+                }
+            }
+            catch (err) {
+                this.$logger.trace(`Cannot resolve ${argument} of hook ${hookFullPath}, reason: ${err}`);
+                invalidArguments.push(argument);
+            }
+        });
+        return invalidArguments;
+    }
+}
+HooksService.HOOKS_DIRECTORY_NAME = "hooks";
+__decorate([
+    (0, decorators_1.memoize)({
+        shouldCache() {
+            return !!this.hooksDirectories.length;
+        },
+    })
+], HooksService.prototype, "initialize", null);
+exports.HooksService = HooksService;
+yok_1.injector.register("hooksService", HooksService);

package/lib/common/services/ios-notification-service.js

@@ -0,0 +1,49 @@
+"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.IOSNotificationService = void 0;
+const constants = require("../constants");
+const yok_1 = require("../yok");
+const _ = require("lodash");
+class IOSNotificationService {
+    constructor($iosDeviceOperations) {
+        this.$iosDeviceOperations = $iosDeviceOperations;
+    }
+    awaitNotification(deviceIdentifier, socket, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const notificationResponse = yield this.$iosDeviceOperations.awaitNotificationResponse([
+                {
+                    deviceId: deviceIdentifier,
+                    socket: socket,
+                    timeout: timeout,
+                    responseCommandType: constants.IOS_RELAY_NOTIFICATION_COMMAND_TYPE,
+                    responsePropertyName: "Name",
+                },
+            ]);
+            return _.first(notificationResponse[deviceIdentifier]).response;
+        });
+    }
+    postNotification(deviceIdentifier, notification, commandType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            commandType = commandType || constants.IOS_POST_NOTIFICATION_COMMAND_TYPE;
+            const response = yield this.$iosDeviceOperations.postNotification([
+                {
+                    deviceId: deviceIdentifier,
+                    commandType: commandType,
+                    notificationName: notification,
+                },
+            ]);
+            return +_.first(response[deviceIdentifier]).response;
+        });
+    }
+}
+exports.IOSNotificationService = IOSNotificationService;
+yok_1.injector.register("iOSNotificationService", IOSNotificationService);