nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/common/services/auto-completion-service.d.ts

@@ -0,0 +1,36 @@
+import { IAutoCompletionService, IFileSystem, IChildProcess, IHostInfo } from "../declarations";
+export declare class AutoCompletionService implements IAutoCompletionService {
+    private $fs;
+    private $childProcess;
+    private $logger;
+    private $staticConfig;
+    private $hostInfo;
+    private scriptsOk;
+    private scriptsUpdated;
+    private static COMPLETION_START_COMMENT_PATTERN;
+    private static COMPLETION_END_COMMENT_PATTERN;
+    private static TABTAB_COMPLETION_START_REGEX_PATTERN;
+    private static TABTAB_COMPLETION_END_REGEX_PATTERN;
+    private static GENERATED_TABTAB_COMPLETION_END;
+    private static GENERATED_TABTAB_COMPLETION_START;
+    constructor($fs: IFileSystem, $childProcess: IChildProcess, $logger: ILogger, $staticConfig: Config.IStaticConfig, $hostInfo: IHostInfo);
+    disableAnalytics: boolean;
+    private get shellProfiles();
+    private get cliRunCommandsFile();
+    private getTabTabObsoleteRegex;
+    private getTabTabCompletionsRegex;
+    private removeObsoleteAutoCompletion;
+    private removeOboleteTabTabCompletion;
+    private get completionAliasDefinition();
+    private get completionShellScriptContent();
+    isAutoCompletionEnabled(): boolean;
+    disableAutoCompletion(): void;
+    enableAutoCompletion(): Promise<void>;
+    isObsoleteAutoCompletionEnabled(): boolean;
+    private isNewAutoCompletionEnabledInFile;
+    private isObsoleteAutoCompletionEnabledInFile;
+    private addAutoCompletionToShellScript;
+    private removeAutoCompletionFromShellScript;
+    private updateCLIShellScript;
+    private getHomePath;
+}

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

@@ -27,15 +27,12 @@ class AutoCompletionService {
     get shellProfiles() {
         return [
             this.getHomePath(".bashrc"),
-            this.getHomePath(".zshrc"), // zsh - http://www.acm.uiuc.edu/workshops/zsh/startup_files.html
+            this.getHomePath(".zshrc"),
         ];
     }
     get cliRunCommandsFile() {
         let cliRunCommandsFile = this.getHomePath(util.format(".%src", this.$staticConfig.CLIENT_NAME.toLowerCase()));
         if (this.$hostInfo.isWindows) {
-            // on Windows bash, file is incorrectly written as C:\Users\<username>, which leads to errors when trying to execute the script:
-            // $ source ~/.bashrc
-            // sh.exe": C:Usersusername.appbuilderrc: No such file or directory
             cliRunCommandsFile = cliRunCommandsFile.replace(/\\/g, "/");
         }
         return cliRunCommandsFile;
@@ -50,9 +47,7 @@ class AutoCompletionService {
         return new RegExp(util.format("%s[\\s\\S]*%s", AutoCompletionService.GENERATED_TABTAB_COMPLETION_START, AutoCompletionService.GENERATED_TABTAB_COMPLETION_END));
     }
     removeObsoleteAutoCompletion() {
-        // In previous releases we were writing directly in .bash_profile, .bashrc, .zshrc and .profile - remove this old code
         const shellProfilesToBeCleared = this.shellProfiles;
-        // Add .profile only here as we do not want new autocompletion in this file, but we have to remove our old code from it.
         shellProfilesToBeCleared.push(this.getHomePath(".profile"));
         shellProfilesToBeCleared.forEach((file) => {
             try {
@@ -105,7 +100,6 @@ class AutoCompletionService {
                 this.isNewAutoCompletionEnabledInFile(filePath) ||
                     this.isObsoleteAutoCompletionEnabledInFile(filePath);
             if (!result) {
-                // break each
                 return false;
             }
         });
@@ -131,7 +125,6 @@ class AutoCompletionService {
         _.each(this.shellProfiles, (shellProfile) => {
             result = this.isObsoleteAutoCompletionEnabledInFile(shellProfile);
             if (!result) {
-                // break each
                 return false;
             }
         });
@@ -170,8 +163,6 @@ class AutoCompletionService {
         }
         catch (err) {
             this.$logger.info("Unable to update %s. Command-line completion might not work.", fileName);
-            // When npm is installed with sudo, in some cases the installation cannot write to shell profiles
-            // Advise the user how to enable autocompletion after the installation is completed.
             if ((err.code === "EPERM" || err.code === "EACCES") &&
                 !this.$hostInfo.isWindows &&
                 process.env.SUDO_USER) {
@@ -192,7 +183,6 @@ class AutoCompletionService {
             }
         }
         catch (err) {
-            // If file does not exist, autocompletion was not working for it, so ignore this error.
             if (err.code !== "ENOENT") {
                 this.$logger.info("Failed to update %s. Auto-completion may still work or work incorrectly. ", fileName);
                 this.$logger.info(err);
@@ -224,7 +214,6 @@ class AutoCompletionService {
                         this.$fs.writeFile(filePath, newText);
                     }
                 }
-                // The generated seems to be inconsistent in it's start/end markers so adding our own.
                 this.$fs.appendFile(filePath, `\n${AutoCompletionService.GENERATED_TABTAB_COMPLETION_START}\n`);
                 await this.$childProcess.exec(`"${process.argv[0]}" "${pathToExecutableFile}" completion_generate_script >> "${filePath}"`);
                 this.$fs.appendFile(filePath, this.completionAliasDefinition);
@@ -261,4 +250,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], AutoCompletionService.prototype, "completionShellScriptContent", null);
 yok_1.injector.register("autoCompletionService", AutoCompletionService);
-//# sourceMappingURL=auto-completion-service.js.map

package/lib/common/services/cancellation.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/common/services/cancellation.js

@@ -4,6 +4,7 @@ const choki = require("chokidar");
 const path = require("path");
 const os = require("os");
 const _ = require("lodash");
+const enums_1 = require("../enums");
 const yok_1 = require("../yok");
 class CancellationService {
     constructor($fs, $logger, $hostInfo) {
@@ -28,7 +29,7 @@ class CancellationService {
             .watch(triggerFile, { ignoreInitial: true })
             .on("unlink", (filePath) => {
             this.$logger.info(`Exiting process as the file ${filePath} has been deleted. Probably reinstalling CLI while there's a working instance.`);
-            process.exit(132 /* ErrorCodes.DELETED_KILL_FILE */);
+            process.exit(enums_1.ErrorCodes.DELETED_KILL_FILE);
         });
         if (watcher) {
             this.watches[name] = watcher;
@@ -54,4 +55,3 @@ class CancellationService {
     }
 }
 yok_1.injector.register("cancellation", CancellationService);
-//# sourceMappingURL=cancellation.js.map

package/lib/common/services/command-definition-adapter.d.ts

@@ -0,0 +1,6 @@
+import { IInjector } from "../definitions/yok";
+import { ICommand } from "../definitions/commands";
+import { CommandDefinition, CommandOptionsSchema, DefinedCommand } from "../define-command";
+export declare function createCommandFromDefinition<TSchema extends CommandOptionsSchema>(definition: CommandDefinition<TSchema>, targetInjector?: IInjector): ICommand;
+export declare function registerDefinitionAs<TSchema extends CommandOptionsSchema>(name: string, definition: DefinedCommand<TSchema>, targetInjector?: IInjector): void;
+export declare function registerCommandDefinition<TSchema extends CommandOptionsSchema>(definition: DefinedCommand<TSchema>, targetInjector?: IInjector): void;

package/lib/common/services/command-definition-adapter.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandFromDefinition = createCommandFromDefinition;
+exports.registerDefinitionAs = registerDefinitionAs;
+exports.registerCommandDefinition = registerCommandDefinition;
+const enums_1 = require("../enums");
+const yok_1 = require("../yok");
+const inject_1 = require("../di/inject");
+const command_registry_1 = require("../contracts/command-registry");
+const define_command_1 = require("../define-command");
+const OPTION_TYPES = {
+    boolean: enums_1.OptionType.Boolean,
+    string: enums_1.OptionType.String,
+    number: enums_1.OptionType.Number,
+    array: enums_1.OptionType.Array,
+};
+const compileOptions = (schema) => {
+    const dashedOptions = {};
+    for (const optionName of Object.keys(schema)) {
+        const spec = schema[optionName];
+        const dashedOption = {
+            type: OPTION_TYPES[spec.type],
+            hasSensitiveValue: spec.hasSensitiveValue === true,
+        };
+        if (spec.default !== undefined) {
+            dashedOption.default = spec.default;
+        }
+        if (spec.alias !== undefined) {
+            dashedOption.alias = spec.alias;
+        }
+        if (spec.description !== undefined) {
+            dashedOption.describe = spec.description;
+        }
+        dashedOptions[optionName] = dashedOption;
+    }
+    return dashedOptions;
+};
+const aliasList = (alias) => alias === undefined ? [] : Array.isArray(alias) ? alias : [alias];
+const warnOnCliOptionCollisions = (targetInjector, definition, schema, optionsService) => {
+    const cliOptions = optionsService && optionsService.options;
+    if (!cliOptions) {
+        return;
+    }
+    const cliSpellings = {};
+    for (const cliName of Object.keys(cliOptions)) {
+        cliSpellings[cliName] = cliName;
+        for (const alias of aliasList(cliOptions[cliName].alias)) {
+            cliSpellings[alias] = cliName;
+        }
+    }
+    const collisions = [];
+    for (const optionName of Object.keys(schema)) {
+        if (cliSpellings[optionName]) {
+            collisions.push(`'--${optionName}' with the CLI option '--${cliSpellings[optionName]}'`);
+        }
+        for (const alias of aliasList(schema[optionName].alias)) {
+            if (cliSpellings[alias]) {
+                collisions.push(`alias '-${alias}' of '--${optionName}' with the CLI option '--${cliSpellings[alias]}'`);
+            }
+        }
+    }
+    if (!collisions.length) {
+        return;
+    }
+    const logger = targetInjector.get("logger", { optional: true });
+    if (!logger) {
+        return;
+    }
+    const commandName = Array.isArray(definition.name)
+        ? definition.name[0]
+        : definition.name;
+    logger.warn(`Command '${commandName}' declares options that collide with CLI-wide ` +
+        `ones: ${collisions.join("; ")}. The command's declaration wins while ` +
+        `the command runs; rename them to avoid it.`);
+};
+function createCommandFromDefinition(definition, targetInjector = yok_1.injector) {
+    const schema = definition.options || {};
+    const optionNames = Object.keys(schema);
+    const dashedOptions = compileOptions(schema);
+    const optionsService = optionNames.length
+        ? targetInjector.resolve("options")
+        : null;
+    warnOnCliOptionCollisions(targetInjector, definition, schema, optionsService);
+    const commandName = Array.isArray(definition.name)
+        ? definition.name[0]
+        : definition.name;
+    const fail = (message) => {
+        if (typeof message !== "string" || !message.trim()) {
+            throw new Error(`ctx.fail() for command '${commandName}' requires a non-empty message.`);
+        }
+        const errors = targetInjector.resolve("errors");
+        return errors.failWithHelp(message);
+    };
+    const buildContext = (args) => {
+        const options = {};
+        for (const optionName of optionNames) {
+            options[optionName] = optionsService[optionName];
+        }
+        return { args, options, fail };
+    };
+    const acceptsArguments = definition.arguments === "any";
+    return {
+        allowedParameters: [],
+        dashedOptions,
+        ...(definition.disableAnalytics === undefined
+            ? {}
+            : { disableAnalytics: definition.disableAnalytics }),
+        ...(definition.enableHooks === undefined
+            ? {}
+            : { enableHooks: definition.enableHooks }),
+        canExecute: async (args) => {
+            if (!acceptsArguments && args.length) {
+                fail("This command doesn't accept parameters.");
+            }
+            const refine = definition.canExecute;
+            if (!refine) {
+                return true;
+            }
+            return await (0, inject_1.runInInjectionContext)(targetInjector, () => refine.call(definition, buildContext(args)));
+        },
+        execute: async (args) => {
+            await (0, inject_1.runInInjectionContext)(targetInjector, () => definition.run(buildContext(args)));
+        },
+    };
+}
+function registerDefinitionAs(name, definition, targetInjector = yok_1.injector) {
+    const registry = targetInjector.get(command_registry_1.CommandRegistry);
+    registry.registerCommand(name, () => createCommandFromDefinition(definition, targetInjector));
+}
+function registerCommandDefinition(definition, targetInjector = yok_1.injector) {
+    if (!(0, define_command_1.isCommandDefinition)(definition)) {
+        throw new Error("registerCommandDefinition() takes the result of defineCommand(); " +
+            "the value passed carries no command-definition marker.");
+    }
+    const names = Array.isArray(definition.name)
+        ? definition.name
+        : [definition.name];
+    for (const name of names) {
+        registerDefinitionAs(name, definition, targetInjector);
+    }
+}

package/lib/common/services/commands-service.d.ts

@@ -0,0 +1,30 @@
+import { IOptions, IOptionsTracker } from "../../declarations";
+import { IErrors, IHooksService } from "../declarations";
+import { IInjector } from "../definitions/yok";
+import { IExtensibilityService } from "../definitions/extensibility";
+export declare class CommandsService implements ICommandsService {
+    private $errors;
+    private $hooksService;
+    private $injector;
+    private $logger;
+    private $options;
+    private $staticConfig;
+    private $extensibilityService;
+    private $optionsTracker;
+    get currentCommandData(): ICommandData;
+    private commands;
+    constructor($errors: IErrors, $hooksService: IHooksService, $injector: IInjector, $logger: ILogger, $options: IOptions, $staticConfig: Config.IStaticConfig, $extensibilityService: IExtensibilityService, $optionsTracker: IOptionsTracker);
+    allCommands(opts: {
+        includeDevCommands: boolean;
+    }): string[];
+    executeCommandUnchecked(commandName: string, commandArguments: string[]): Promise<boolean>;
+    private printHelpSuggestion;
+    private executeCommandAction;
+    private tryExecuteCommandAction;
+    tryExecuteCommand(commandName: string, commandArguments: string[]): Promise<void>;
+    private canExecuteCommand;
+    private validateMandatoryParams;
+    private validateCommandArguments;
+    private tryMatchCommand;
+    private beautifyCommandName;
+}

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

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandsService = void 0;
 const jaroWinklerDistance = require("../vendor/jaro-winkler_distance");
 const helpers = require("../helpers");
+const constants_1 = require("../constants");
 const os_1 = require("os");
 const _ = require("lodash");
+const enums_1 = require("../enums");
 const yok_1 = require("../yok");
 class CommandArgumentsValidationHelper {
     constructor(isValid, _remainingArguments) {
@@ -38,11 +40,11 @@ class CommandsService {
             if (!this.$staticConfig.disableAnalytics &&
                 !command.disableAnalytics &&
                 !this.$options.disableAnalytics) {
-                const analyticsService = this.$injector.resolve("analyticsService"); // This should be resolved here due to cyclic dependency
+                const analyticsService = this.$injector.resolve("analyticsService");
                 await analyticsService.checkConsent();
                 const beautifiedCommandName = this.beautifyCommandName(commandName).replace(/\|/g, " ");
                 const googleAnalyticsPageData = {
-                    googleAnalyticsDataType: "pageview" /* GoogleAnalyticsDataType.Page */,
+                    googleAnalyticsDataType: enums_1.GoogleAnalyticsDataType.Page,
                     path: beautifiedCommandName,
                     title: beautifiedCommandName,
                 };
@@ -52,11 +54,10 @@ class CommandsService {
             const shouldExecuteHooks = !this.$staticConfig.disableCommandHooks &&
                 (command.enableHooks === undefined || command.enableHooks === true);
             if (shouldExecuteHooks) {
-                // Handle correctly hierarchical commands
                 const hierarchicalCommandName = this.$injector.buildHierarchicalCommand(commandName, commandArguments);
                 if (hierarchicalCommandName) {
-                    commandName = helpers.stringReplaceAll(hierarchicalCommandName.commandName, "|*" /* CommandsDelimiters.DefaultHierarchicalCommand */, "-" /* CommandsDelimiters.HooksCommand */);
-                    commandName = helpers.stringReplaceAll(commandName, "|" /* CommandsDelimiters.HierarchicalCommand */, "-" /* CommandsDelimiters.HooksCommand */);
+                    commandName = helpers.stringReplaceAll(hierarchicalCommandName.commandName, constants_1.CommandsDelimiters.DefaultHierarchicalCommand, constants_1.CommandsDelimiters.HooksCommand);
+                    commandName = helpers.stringReplaceAll(commandName, constants_1.CommandsDelimiters.HierarchicalCommand, constants_1.CommandsDelimiters.HooksCommand);
                 }
                 await this.$hooksService.executeBeforeHooks(commandName);
             }
@@ -86,7 +87,8 @@ class CommandsService {
     }
     async tryExecuteCommandAction(commandName, commandArguments) {
         const command = this.$injector.resolveCommand(commandName);
-        if (!command || !command.isHierarchicalCommand) {
+        if (!command ||
+            (!command.isHierarchicalCommand && !command.skipOptionsValidation)) {
             const dashedOptions = command ? command.dashedOptions : null;
             this.$options.validateOptions(dashedOptions);
         }
@@ -101,7 +103,6 @@ class CommandsService {
             await this.executeCommandAction(commandName, commandArguments, this.executeCommandUnchecked);
         }
         else {
-            // If canExecuteCommand returns false, the command cannot be executed or there's no such command at all.
             const command = this.$injector.resolveCommand(commandName);
             if (command) {
                 let commandWithArgs = commandName;
@@ -117,15 +118,12 @@ class CommandsService {
         const command = this.$injector.resolveCommand(commandName);
         const beautifiedName = helpers.stringReplaceAll(commandName, "|", " ");
         if (command) {
-            // Verify command is enabled
             if (command.isDisabled) {
                 this.$errors.fail("This command is not applicable to your environment.");
             }
-            // If command wants to handle canExecute logic on its own.
             if (command.canExecute) {
                 return await command.canExecute(commandArguments);
             }
-            // First part of hierarchical commands should be validated in specific way.
             if (await this.$injector.isValidHierarchicalCommand(commandName, commandArguments)) {
                 return true;
             }
@@ -137,8 +135,8 @@ class CommandsService {
         }
         const commandInfo = {
             inputStrings: [commandName, ...commandArguments],
-            commandDelimiter: "|" /* CommandsDelimiters.HierarchicalCommand */,
-            defaultCommandDelimiter: "|*" /* CommandsDelimiters.DefaultHierarchicalCommand */,
+            commandDelimiter: constants_1.CommandsDelimiters.HierarchicalCommand,
+            defaultCommandDelimiter: constants_1.CommandsDelimiters.DefaultHierarchicalCommand,
         };
         const extensionData = await this.$extensibilityService.getExtensionNameWhereCommandIsRegistered(commandInfo);
         if (extensionData) {
@@ -154,13 +152,11 @@ class CommandsService {
     async validateMandatoryParams(commandArguments, mandatoryParams) {
         const commandArgsHelper = new CommandArgumentsValidationHelper(true, commandArguments);
         if (mandatoryParams.length > 0) {
-            // If command has more mandatory params than the passed ones, we shouldn't execute it
             if (mandatoryParams.length > commandArguments.length) {
                 const customErrorMessages = _.map(mandatoryParams, (mp) => mp.errorMessage);
                 customErrorMessages.splice(0, 0, "You need to provide all the required parameters.");
                 this.$errors.failWithHelp(customErrorMessages.join(os_1.EOL));
             }
-            // If we reach here, the commandArguments are at least as much as mandatoryParams. Now we should verify that we have each of them.
             for (let mandatoryParamIndex = 0; mandatoryParamIndex < mandatoryParams.length; ++mandatoryParamIndex) {
                 const mandatoryParam = mandatoryParams[mandatoryParamIndex];
                 let argument = null;
@@ -187,14 +183,12 @@ class CommandsService {
         if (!commandArgsHelper.isValid) {
             return false;
         }
-        // Command doesn't have any allowedParameters
         if (!command.allowedParameters || command.allowedParameters.length === 0) {
             if (commandArguments.length > 0) {
                 this.$errors.failWithHelp("This command doesn't accept parameters.");
             }
         }
         else {
-            // Exclude mandatory params, we've already checked them
             const unverifiedAllowedParams = command.allowedParameters.filter((param) => !param.mandatory);
             for (let remainingArgsIndex = 0; remainingArgsIndex < commandArgsHelper.remainingArguments.length; ++remainingArgsIndex) {
                 const argument = commandArgsHelper.remainingArguments[remainingArgsIndex];
@@ -208,7 +202,6 @@ class CommandsService {
                 }
                 if (parameter) {
                     const index = unverifiedAllowedParams.indexOf(parameter);
-                    // Remove the matched parameter from unverifiedAllowedParams collection, so it will not be used to verify another argument.
                     unverifiedAllowedParams.splice(index, 1);
                 }
                 else {
@@ -253,4 +246,3 @@ class CommandsService {
 }
 exports.CommandsService = CommandsService;
 yok_1.injector.register("commandsService", CommandsService);
-//# sourceMappingURL=commands-service.js.map

package/lib/common/services/help-service.d.ts

@@ -0,0 +1,46 @@
+import { IHelpService, IErrors, IFileSystem, IMicroTemplateService } from "../declarations";
+import { IInjector } from "../definitions/yok";
+import { IExtensibilityService } from "../definitions/extensibility";
+import { IOpener } from "../../declarations";
+export declare class HelpService implements IHelpService {
+    private $logger;
+    private $injector;
+    private $errors;
+    private $fs;
+    private $staticConfig;
+    private $extensibilityService;
+    private $microTemplateService;
+    private $opener;
+    private static MARKDOWN_FILE_EXTENSION;
+    private static HTML_FILE_EXTENSION;
+    private static MAN_PAGE_NAME_REGEX;
+    private static HTML_COMMAND_HELP_REGEX;
+    private static RELATIVE_PATH_TO_STYLES_CSS_REGEX;
+    private static RELATIVE_PATH_TO_IMAGES_REGEX;
+    private static RELATIVE_PATH_TO_INDEX_REGEX;
+    private static EXTENSION_NAME_REGEX;
+    private static MARKDOWN_LINK_REGEX;
+    private static SPAN_REGEX;
+    private static NEW_LINE_REGEX;
+    private get newLineRegex();
+    private pathToManPages;
+    private pathToHtmlPages;
+    private get pathToStylesCss();
+    private get pathToBasicPage();
+    private get pathToBasicPageForExtensions();
+    private pathToImages;
+    private get pathToIndexHtml();
+    constructor($logger: ILogger, $injector: IInjector, $errors: IErrors, $fs: IFileSystem, $staticConfig: Config.IStaticConfig, $extensibilityService: IExtensibilityService, $microTemplateService: IMicroTemplateService, $opener: IOpener);
+    openHelpForCommandInBrowser(commandData: ICommandData): Promise<void>;
+    generateHtmlPages(): Promise<void>;
+    showCommandLineHelp(commandData: ICommandData): Promise<void>;
+    private getCommandLineHelpForCommand;
+    private createHtmlPage;
+    private convertCommandNameToFileName;
+    private throwMissingCommandError;
+    private static getHtmlDirFullPath;
+    private getHelpFile;
+    private getHelpFileFromExtensions;
+    private tryOpeningSelectedPage;
+    private readMdFileForCommand;
+}

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

@@ -4,6 +4,7 @@ exports.HelpService = void 0;
 const path = require("path");
 const os_1 = require("os");
 const marked_1 = require("marked");
+const constants_1 = require("../constants");
 const yok_1 = require("../yok");
 const _ = require("lodash");
 class HelpService {
@@ -42,7 +43,6 @@ class HelpService {
         this.$logger.trace("Opening help for command '%s'. FileName is '%s'.", commandName, htmlPage);
         this.$fs.ensureDirectoryExists(this.pathToHtmlPages);
         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);
             await this.generateHtmlPages();
             if (!this.tryOpeningSelectedPage(htmlPage)) {
@@ -99,11 +99,6 @@ class HelpService {
         const help = await 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).
-     */
     async getCommandLineHelpForCommand(commandData) {
         const helpText = await this.readMdFileForCommand(commandData);
         const commandLineHelp = (await this.$microTemplateService.parseContent(helpText, { isHtml: false }))
@@ -115,7 +110,6 @@ class HelpService {
             .replace(HelpService.NEW_LINE_REGEX, os_1.EOL);
         return commandLineHelp;
     }
-    // This method should return Promise in order to generate all html pages simultaneously.
     async createHtmlPage(htmlPageGenerationData) {
         const { basicHtmlPage, pathToMdFile, pathToMdPages, pathToHtmlPages, extensionName, } = htmlPageGenerationData;
         const mdFileName = path.basename(pathToMdFile);
@@ -162,8 +156,8 @@ class HelpService {
         const commandName = commandData.commandName;
         const commandInfo = {
             inputStrings: [commandName, ...commandData.commandArguments],
-            commandDelimiter: "|" /* CommandsDelimiters.HierarchicalCommand */,
-            defaultCommandDelimiter: "|*" /* CommandsDelimiters.DefaultHierarchicalCommand */,
+            commandDelimiter: constants_1.CommandsDelimiters.HierarchicalCommand,
+            defaultCommandDelimiter: constants_1.CommandsDelimiters.DefaultHierarchicalCommand,
         };
         const extensionData = await this.$extensibilityService.getExtensionNameWhereCommandIsRegistered(commandInfo);
         if (extensionData) {
@@ -230,6 +224,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 />
+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.d.ts

@@ -0,0 +1,40 @@
+import type { HookMiddleware } from "../define-hook";
+import { IOptions, IPerformanceService } from "../../declarations";
+import { IHooksService, IDictionary, IChildProcess, IFileSystem, IErrors, IProjectHelper, IHookExecutionOptions } from "../declarations";
+import { IProjectConfigService } from "../../definitions/project";
+import { IInjector } from "../definitions/yok";
+export declare class HooksService implements IHooksService {
+    private $childProcess;
+    private $fs;
+    private $logger;
+    private $errors;
+    private $config;
+    private $staticConfig;
+    private $injector;
+    private $projectHelper;
+    private $options;
+    private $performanceService;
+    private $projectConfigService;
+    private static HOOKS_DIRECTORY_NAME;
+    private cachedHooks;
+    private hooksDirectories;
+    constructor($childProcess: IChildProcess, $fs: IFileSystem, $logger: ILogger, $errors: IErrors, $config: Config.IConfig, $staticConfig: Config.IStaticConfig, $injector: IInjector, $projectHelper: IProjectHelper, $options: IOptions, $performanceService: IPerformanceService, $projectConfigService: IProjectConfigService);
+    get hookArgsName(): string;
+    private initialize;
+    private static formatHookName;
+    executeBeforeHooks(commandName: string, hookArguments?: IDictionary<any>, options?: IHookExecutionOptions): Promise<HookMiddleware[]>;
+    executeAfterHooks(commandName: string, hookArguments?: IDictionary<any>): Promise<void>;
+    private executeHooks;
+    private isESModule;
+    private executeHook;
+    private executeHookDefinition;
+    private executeHooksInDirectory;
+    private getCustomHooksByName;
+    private getHooksByName;
+    private getHooksInDirectory;
+    private prepareEnvironment;
+    private getSheBangInterpreter;
+    private getBaseFilename;
+    private shouldExecuteInProcess;
+    private validateHookArguments;
+}