nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/lib/common/project-helper.d.ts

@@ -0,0 +1,15 @@
+import { IErrors, IFileSystem, IProjectHelper } from "./declarations";
+import { IOptions } from "../declarations";
+export declare class ProjectHelper implements IProjectHelper {
+    private $logger;
+    private $fs;
+    private $staticConfig;
+    private $errors;
+    private $options;
+    constructor($logger: ILogger, $fs: IFileSystem, $staticConfig: Config.IStaticConfig, $errors: IErrors, $options: IOptions);
+    private cachedProjectDir;
+    get projectDir(): string;
+    generateDefaultAppId(appName: string, baseAppId: string): string;
+    sanitizeName(appName: string): string;
+    private isProjectFileCorrect;
+}

package/lib/common/prompter.d.ts

@@ -0,0 +1,23 @@
+import { IAllowEmpty, IPrompterOptions, IPrompterQuestion } from "./declarations";
+export declare class Prompter implements IPrompter {
+    private ctrlcReader;
+    private muteStreamInstance;
+    dispose(): void;
+    get(questions: IPrompterQuestion[]): Promise<any>;
+    getPassword(message: string, options?: IAllowEmpty): Promise<string>;
+    getString(message: string, options?: IPrompterOptions): Promise<string>;
+    promptForChoice(promptMessage: string, choices: string[] | {
+        title: string;
+        description?: string;
+        value?: string;
+    }[], multiple?: boolean, options?: any): Promise<string>;
+    promptForDetailedChoice(promptMessage: string, choices: {
+        key: string;
+        description: string;
+    }[]): Promise<string>;
+    confirm(message: string, defaultAction?: () => boolean): Promise<boolean>;
+    private muteStdout;
+    private unmuteStdout;
+    private cleanEventListeners;
+    private cleanListener;
+}

package/lib/common/queue.d.ts

@@ -0,0 +1,8 @@
+import { IQueue } from "./declarations";
+export declare class Queue<T> implements IQueue<T> {
+    private items?;
+    private promiseResolve;
+    constructor(items?: T[]);
+    enqueue(item: T): void;
+    dequeue(): Promise<T>;
+}

package/lib/common/resource-loader.d.ts

@@ -0,0 +1,10 @@
+import { IResourceLoader, IFileSystem } from "./declarations";
+export declare class ResourceLoader implements IResourceLoader {
+    private $fs;
+    private $staticConfig;
+    constructor($fs: IFileSystem, $staticConfig: Config.IStaticConfig);
+    resolvePath(resourcePath: string): string;
+    openFile(resourcePath: string): NodeJS.ReadableStream;
+    readText(resourcePath: string): string;
+    readJson(resourcePath: string): any;
+}

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

@@ -0,0 +1,9 @@
+export declare enum GoogleAnalyticsCustomDimensions {
+    cliVersion = "cd1",
+    projectType = "cd2",
+    clientID = "cd3",
+    sessionID = "cd4",
+    client = "cd5",
+    nodeVersion = "cd6",
+    isShared = "cd9"
+}

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/cancellation.d.ts

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

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

@@ -87,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);
         }

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/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;
+}

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

@@ -11,6 +11,9 @@ const path = require("path");
 const util = require("util");
 const _ = require("lodash");
 const helpers_1 = require("../helpers");
+const deprecation_1 = require("../deprecation");
+const define_hook_1 = require("../define-hook");
+const inject_1 = require("../di/inject");
 const constants_1 = require("../../constants");
 const yok_1 = require("../yok");
 const color_1 = require("../../color");
@@ -54,17 +57,17 @@ class HooksService {
     static formatHookName(commandName) {
         return commandName.replace(/\|[\s\S]*$/, "");
     }
-    executeBeforeHooks(commandName, hookArguments) {
+    executeBeforeHooks(commandName, hookArguments, options) {
         const beforeHookName = `before-${HooksService.formatHookName(commandName)}`;
         const traceMessage = `BeforeHookName for command ${commandName} is ${beforeHookName}`;
-        return this.executeHooks(beforeHookName, traceMessage, hookArguments);
+        return this.executeHooks(beforeHookName, traceMessage, hookArguments, !!(options && options.consumesMiddlewares));
     }
     executeAfterHooks(commandName, hookArguments) {
         const afterHookName = `after-${HooksService.formatHookName(commandName)}`;
         const traceMessage = `AfterHookName for command ${commandName} is ${afterHookName}`;
-        return this.executeHooks(afterHookName, traceMessage, hookArguments);
+        return this.executeHooks(afterHookName, traceMessage, hookArguments, false);
     }
-    async executeHooks(hookName, traceMessage, hookArguments) {
+    async executeHooks(hookName, traceMessage, hookArguments, consumesMiddlewares) {
         if (this.$config.DISABLE_HOOKS || !this.$options.hooks) {
             return;
         }
@@ -80,11 +83,11 @@ class HooksService {
         const results = [];
         try {
             for (const hooksDirectory of this.hooksDirectories) {
-                results.push(await this.executeHooksInDirectory(hooksDirectory, hookName, hookArguments));
+                results.push(await this.executeHooksInDirectory(hooksDirectory, hookName, hookArguments, consumesMiddlewares));
             }
             const customHooks = this.getCustomHooksByName(hookName);
             for (const hook of customHooks) {
-                results.push(await this.executeHook(this.$projectHelper.projectDir, hookName, hook, hookArguments));
+                results.push(await this.executeHook(this.$projectHelper.projectDir, hookName, hook, hookArguments, consumesMiddlewares));
             }
         }
         catch (err) {
@@ -97,7 +100,8 @@ class HooksService {
         const ext = path.extname(hook.fullPath).toLowerCase();
         return ext === ".mjs";
     }
-    async executeHook(directoryPath, hookName, hook, hookArguments) {
+    async executeHook(directoryPath, hookName, hook, hookArguments, consumesMiddlewares) {
+        var _a;
         hookArguments = hookArguments || {};
         let result;
         const relativePath = path.relative(directoryPath, hook.fullPath);
@@ -123,37 +127,62 @@ class HooksService {
                 hookEntryPoint = hookFn;
             }
             else {
-                hookEntryPoint = require(hook.fullPath);
+                const hookModule = require(hook.fullPath);
+                hookEntryPoint =
+                    hookModule && typeof hookModule.default === "function"
+                        ? hookModule.default
+                        : hookModule;
             }
-            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 definitionCandidate = (_a = (hookEntryPoint && hookEntryPoint.default)) !== null && _a !== void 0 ? _a : hookEntryPoint;
+            if (Array.isArray(definitionCandidate)) {
+                throw new Error(`${hook.fullPath} exports an array, which is not a supported hook entry point. Export a single hook definition or function per file.`);
+            }
+            if ((0, define_hook_1.isHookDefinition)(definitionCandidate)) {
+                result = await this.executeHookDefinition(definitionCandidate, hookName, hook, hookArguments, consumesMiddlewares);
             }
-            const projectDataHookArg = hookArguments["hookArgs"] && hookArguments["hookArgs"]["projectData"];
-            if (projectDataHookArg) {
-                hookArguments["projectData"] = hookArguments["$projectData"] =
-                    projectDataHookArg;
+            else if (typeof hookEntryPoint !== "function") {
+                this.$logger.warn(`${hook.fullPath} will NOT be executed because it does not export a function.`);
+                return;
             }
-            const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
-            if (maybePromise) {
-                this.$logger.trace("Hook promises to signal completion");
-                try {
-                    result = await maybePromise;
+            else {
+                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;
                 }
-                catch (err) {
-                    if (err &&
-                        _.isBoolean(err.stopExecution) &&
-                        err.errorAsWarning === true) {
-                        this.$logger.warn(err.message || err);
+                const usesParamNameInjection = (hookEntryPoint.$inject.args).some((argument) => argument !== this.hookArgsName);
+                if (usesParamNameInjection) {
+                    (0, deprecation_1.reportDeprecation)({
+                        api: "hooks.param-name-signature",
+                        detail: hook.fullPath,
+                        logger: this.$logger,
+                    });
+                }
+                const maybePromise = this.$injector.resolve(hookEntryPoint, hookArguments);
+                if (maybePromise) {
+                    this.$logger.trace("Hook promises to signal completion");
+                    try {
+                        result = await 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 {
+                            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 {
@@ -172,18 +201,47 @@ class HooksService {
         ]);
         return result;
     }
-    async executeHooksInDirectory(directoryPath, hookName, hookArguments) {
+    async executeHookDefinition(definition, hookName, hook, hookArguments, consumesMiddlewares) {
+        if (definition.name !== hookName) {
+            this.$logger.warn(`${hook.fullPath} will NOT be executed: it defines the "${definition.name}" hook but is placed at the "${hookName}" hook point.`);
+            return;
+        }
+        const { context, middlewares } = (0, define_hook_1.createHookInvocation)(hookArguments, {
+            hookName,
+            consumesMiddlewares,
+        });
+        try {
+            const returnedValue = await (0, inject_1.runInInjectionContext)(this.$injector, () => definition.run(context));
+            if (typeof returnedValue === "function") {
+                this.$logger.warn(`${hook.fullPath} returned a function. Returning a middleware is the legacy convention and is ignored for hook definitions — use ctx.wrap() instead.`);
+            }
+        }
+        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");
+        return middlewares.length ? middlewares : undefined;
+    }
+    async executeHooksInDirectory(directoryPath, hookName, hookArguments, consumesMiddlewares) {
         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);
+            const result = await this.executeHook(directoryPath, hookName, hook, hookArguments, consumesMiddlewares);
             if (result) {
                 results.push(result);
             }
         }
-        return results;
+        return _.flatten(results);
     }
     getCustomHooksByName(hookName) {
         const hooks = [];
@@ -266,26 +324,27 @@ class HooksService {
     }
     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 ts = require("typescript");
+            const sourceFile = ts.createSourceFile("hook.js", scriptSource, ts.ScriptTarget.Latest, false, ts.ScriptKind.JS);
+            const isExportsTarget = (node) => {
+                if (!ts.isPropertyAccessExpression(node)) {
+                    return false;
                 }
-                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;
+                if (!ts.isIdentifier(node.expression)) {
+                    return false;
                 }
+                const object = node.expression.text;
+                const property = node.name.text;
+                return ((object === "module" && property === "exports") ||
+                    (object === "exports" && property === "default"));
+            };
+            return sourceFile.statements.some((statement) => {
+                return (ts.isExpressionStatement(statement) &&
+                    ts.isBinaryExpression(statement.expression) &&
+                    statement.expression.operatorToken.kind ===
+                        ts.SyntaxKind.EqualsToken &&
+                    isExportsTarget(statement.expression.left));
             });
-            return inproc;
         }
         catch (err) {
             return false;

package/lib/common/services/ios-notification-service.d.ts

@@ -0,0 +1,7 @@
+import { IiOSNotificationService } from "../declarations";
+export declare class IOSNotificationService implements IiOSNotificationService {
+    private $iosDeviceOperations;
+    constructor($iosDeviceOperations: IIOSDeviceOperations);
+    awaitNotification(deviceIdentifier: string, socket: number, timeout: number): Promise<string>;
+    postNotification(deviceIdentifier: string, notification: string, commandType?: string): Promise<number>;
+}