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

package/lib/common/yok.js

@@ -2,26 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Yok = exports.injector = void 0;
 exports.register = register;
+exports.getInjector = getInjector;
 exports.setGlobalInjector = setGlobalInjector;
 const path = require("path");
 const _ = require("lodash");
 const helpers_1 = require("./helpers");
+const deprecation_1 = require("./deprecation");
 const constants_1 = require("./constants");
-let indent = "";
-function trace(formatStr, ...args) {
-    // uncomment following lines when debugging dependency injection
-    // const items: any[] = [];
-    // for (let _i = 1; _i < arguments.length; _i++) {
-    // 	items[_i - 1] = arguments[_i];
-    // }
-    // const util = require("util");
-    // console.log(util.format.apply(util, [indent + formatStr].concat(args)));
-}
-function pushIndent() {
-    indent += "  ";
-}
-function popIndent() {
-    indent = indent.slice(0, -2);
+const constants_2 = require("./constants");
+const injector_1 = require("./di/injector");
+const contracts_1 = require("./contracts");
+function rejected(rejection) {
+    return { registered: false, rejection };
 }
 function forEachName(names, action) {
     if (_.isString(names)) {
@@ -33,49 +25,119 @@ function forEachName(names, action) {
 }
 function register(...rest) {
     return function (target) {
-        // TODO: Check if 'rest' has more arguments that have to be registered
         exports.injector.register(rest[0], target);
     };
 }
-class Yok {
+class Yok extends injector_1.Injector {
     constructor() {
+        super();
         this.overrideAlreadyRequiredModule = false;
         this.COMMANDS_NAMESPACE = "commands";
+        this.synthesizedParents = new Set();
+        this.placeholderParents = new Set();
         this.KEY_COMMANDS_NAMESPACE = "keyCommands";
-        this.modules = {};
-        this.resolutionProgress = {};
-        this.hierarchicalCommands = {};
+        this.hierarchicalCommands = Object.create(null);
+        this.deferredCommandOwners = Object.create(null);
         this.publicApi = {
             __modules__: {},
         };
         this.register("injector", this);
+        this.register([
+            { provide: contracts_1.CommandRegistry, useValue: this },
+            { provide: contracts_1.KeyCommandRegistry, useValue: this },
+            { provide: contracts_1.ModuleRegistry, useValue: this },
+            { provide: contracts_1.PublicApiBuilder, useValue: this },
+        ]);
     }
     requireCommand(names, file) {
         forEachName(names, (commandName) => {
-            const commands = commandName.split("|" /* CommandsDelimiters.HierarchicalCommand */);
+            const commands = commandName.split(constants_2.CommandsDelimiters.HierarchicalCommand);
             if (commands.length > 1) {
                 if (_.startsWith(commands[1], "*") &&
-                    this.modules[this.createCommandName(commands[0])]) {
+                    this.has(this.createCommandName(commands[0])) &&
+                    !this.synthesizedParents.has(commands[0])) {
                     throw new Error("Default commands should be required before child commands");
                 }
                 const parentCommandName = commands[0];
                 if (!this.hierarchicalCommands[parentCommandName]) {
                     this.hierarchicalCommands[parentCommandName] = [];
                 }
-                this.hierarchicalCommands[parentCommandName].push(_.tail(commands).join("|" /* CommandsDelimiters.HierarchicalCommand */));
+                this.hierarchicalCommands[parentCommandName].push(_.tail(commands).join(constants_2.CommandsDelimiters.HierarchicalCommand));
             }
             if (commands.length > 1 &&
-                !this.modules[this.createCommandName(commands[0])]) {
+                !this.has(this.createCommandName(commands[0]))) {
+                this.placeholderParents.add(commands[0]);
                 this.require(this.createCommandName(commands[0]), file);
                 if (commands[1] && !commandName.match(/\|\*/)) {
                     this.require(this.createCommandName(commandName), file);
                 }
             }
-            else {
+            else if (!commandName.match(/\|\*/)) {
                 this.require(this.createCommandName(commandName), file);
             }
         });
     }
+    registerDeferredCommand(name, options) {
+        if (name !== name.toLowerCase()) {
+            return rejected({
+                reason: "invalid-name",
+                detail: `command names are matched in lower case, so '${name}' can never ` +
+                    `be dispatched; declare it as '${name.toLowerCase()}'`,
+            });
+        }
+        const claimedBy = this.deferredCommandOwners[name];
+        if (claimedBy) {
+            return claimedBy === options.owner
+                ? { registered: true }
+                : rejected({ reason: "claimed", owner: claimedBy });
+        }
+        const commandRecordName = this.createCommandName(name);
+        if (this.has(commandRecordName)) {
+            return rejected(this.synthesizedParents.has(name)
+                ? { reason: "subcommand-parent" }
+                : { reason: "built-in" });
+        }
+        const commands = name.split(constants_2.CommandsDelimiters.HierarchicalCommand);
+        const parentCommandName = commands.length > 1 ? commands[0] : null;
+        if (parentCommandName &&
+            this.has(this.createCommandName(parentCommandName)) &&
+            !this.synthesizedParents.has(parentCommandName) &&
+            !this.placeholderParents.has(parentCommandName)) {
+            return rejected({
+                reason: "parent-is-command",
+                parent: parentCommandName,
+            });
+        }
+        super.register({
+            provide: commandRecordName,
+            useLazyRequire: () => {
+                try {
+                    options.load();
+                }
+                catch (err) {
+                    throw new Error(`Unable to load command '${name}' of ${options.owner} from ` +
+                        `${options.source}: ${err.message}`);
+                }
+                if (!this.hasResolver(commandRecordName)) {
+                    throw new Error(`Command '${name}' of ${options.owner} was not registered when ` +
+                        `${options.source} loaded. The module must export a ` +
+                        `defineCommand() definition or register the command itself.`);
+                }
+            },
+        });
+        this.deferredCommandOwners[name] = options.owner;
+        if (parentCommandName) {
+            const subCommandName = _.tail(commands).join(constants_2.CommandsDelimiters.HierarchicalCommand);
+            if (!this.hierarchicalCommands[parentCommandName]) {
+                this.hierarchicalCommands[parentCommandName] = [];
+            }
+            if (!_.includes(this.hierarchicalCommands[parentCommandName], subCommandName)) {
+                this.hierarchicalCommands[parentCommandName].push(subCommandName);
+            }
+            this.createHierarchicalCommand(parentCommandName, name);
+        }
+        return { registered: true };
+    }
     require(names, file) {
         forEachName(names, (name) => this.requireOne(name, file));
     }
@@ -110,7 +172,7 @@ class Yok {
         });
     }
     resolveInstance(name) {
-        let classInstance = _.first(this.modules[name].instances);
+        let classInstance = this.peek(name);
         if (!classInstance) {
             classInstance = this.resolve(name);
         }
@@ -118,14 +180,15 @@ class Yok {
     }
     requireOne(name, file) {
         const relativePath = path.join("../", file);
-        const dependency = {
-            require: require("fs").existsSync(path.join(__dirname, relativePath + ".js"))
-                ? relativePath
-                : file,
-            shared: true,
-        };
-        if (!this.modules[name] || this.overrideAlreadyRequiredModule) {
-            this.modules[name] = dependency;
+        const dependencyPath = require("fs").existsSync(path.join(__dirname, relativePath + ".js"))
+            ? relativePath
+            : file;
+        if (!this.has(name) || this.overrideAlreadyRequiredModule) {
+            this.remove(name);
+            super.register({
+                provide: name,
+                useLazyRequire: () => require(dependencyPath),
+            });
         }
         else {
             throw new Error(`module '${name}' require'd twice.`);
@@ -133,10 +196,18 @@ class Yok {
     }
     registerCommand(names, resolver) {
         forEachName(names, (name) => {
-            const commands = name.split("|" /* CommandsDelimiters.HierarchicalCommand */);
+            const commands = name.split(constants_2.CommandsDelimiters.HierarchicalCommand);
             this.register(this.createCommandName(name), resolver);
             if (commands.length > 1) {
-                this.createHierarchicalCommand(commands[0]);
+                const parentCommandName = commands[0];
+                const subCommandName = _.tail(commands).join(constants_2.CommandsDelimiters.HierarchicalCommand);
+                if (!this.hierarchicalCommands[parentCommandName]) {
+                    this.hierarchicalCommands[parentCommandName] = [];
+                }
+                if (!_.includes(this.hierarchicalCommands[parentCommandName], subCommandName)) {
+                    this.hierarchicalCommands[parentCommandName].push(subCommandName);
+                }
+                this.createHierarchicalCommand(parentCommandName, name);
             }
         });
     }
@@ -145,7 +216,7 @@ class Yok {
     }
     getDefaultCommand(name, commandArguments) {
         const subCommands = this.hierarchicalCommands[name];
-        const defaultCommand = _.find(subCommands, (command) => _.some(command.split("|" /* CommandsDelimiters.HierarchicalCommand */), (c) => _.startsWith(c, "*" /* CommandsDelimiters.DefaultCommandSymbol */)));
+        const defaultCommand = _.find(subCommands, (command) => _.some(command.split(constants_2.CommandsDelimiters.HierarchicalCommand), (c) => _.startsWith(c, constants_2.CommandsDelimiters.DefaultCommandSymbol)));
         return defaultCommand;
     }
     buildHierarchicalCommand(parentCommandName, commandLineArguments) {
@@ -161,7 +232,7 @@ class Yok {
             remainingArguments = _.tail(remainingArguments);
             if ((matchingSubCommandName = _.find(subCommands, (sc) => sc === currentSubCommandName ||
                 sc ===
-                    `${"*" /* CommandsDelimiters.DefaultCommandSymbol */}${currentSubCommandName}`))) {
+                    `${constants_2.CommandsDelimiters.DefaultCommandSymbol}${currentSubCommandName}`))) {
                 finalSubCommandName = matchingSubCommandName;
                 finalRemainingArguments = remainingArguments;
             }
@@ -170,9 +241,9 @@ class Yok {
             finalSubCommandName =
                 this.getDefaultCommand(parentCommandName, commandLineArguments) || "";
             finalRemainingArguments = _.difference(commandLineArguments, finalSubCommandName
-                .split("|" /* CommandsDelimiters.HierarchicalCommand */)
-                .map((command) => _.startsWith(command, "*" /* CommandsDelimiters.DefaultCommandSymbol */)
-                ? command.substr(1)
+                .split(constants_2.CommandsDelimiters.HierarchicalCommand)
+                .map((command) => _.startsWith(command, constants_2.CommandsDelimiters.DefaultCommandSymbol)
+                ? command.slice(1)
                 : command));
         }
         if (finalSubCommandName) {
@@ -182,13 +253,24 @@ class Yok {
             };
         }
     }
-    createHierarchicalCommand(name) {
+    createHierarchicalCommand(name, triggeredBy) {
+        if (this.has(this.createCommandName(name)) &&
+            !this.synthesizedParents.has(name) &&
+            !this.placeholderParents.has(name)) {
+            const logger = this.get("logger", { optional: true });
+            if (logger) {
+                logger.warn(`'${name}' is already registered as a command of its own, so no ` +
+                    `subcommand dispatcher was created for it${triggeredBy ? ` and '${triggeredBy}' cannot be reached` : ""}. Rename one of the two.`);
+            }
+            return;
+        }
+        this.synthesizedParents.add(name);
         const factory = () => {
             return {
                 disableAnalytics: true,
                 isHierarchicalCommand: true,
                 execute: async (args) => {
-                    const commandsService = exports.injector.resolve("commandsService");
+                    const commandsService = this.resolve("commandsService");
                     let commandName = null;
                     const defaultCommand = this.getDefaultCommand(name, args);
                     let commandArguments = [];
@@ -202,9 +284,7 @@ class Yok {
                             commandName = defaultCommand
                                 ? this.getHierarchicalCommandName(name, defaultCommand)
                                 : "help";
-                            // If we'll execute the default command, but it's full name had been written by the user
-                            // for example "ns run ios", we have to remove the "ios" option from the arguments that we'll pass to the command.
-                            if (_.includes(this.hierarchicalCommands[name], "*" /* CommandsDelimiters.DefaultCommandSymbol */ + args[0])) {
+                            if (_.includes(this.hierarchicalCommands[name], constants_2.CommandsDelimiters.DefaultCommandSymbol + args[0])) {
                                 commandArguments = _.tail(args);
                             }
                             else {
@@ -213,13 +293,11 @@ class Yok {
                         }
                     }
                     else {
-                        //Execute only default command without arguments
                         if (defaultCommand) {
                             commandName = this.getHierarchicalCommandName(name, defaultCommand);
                         }
                         else {
                             commandName = "help";
-                            // Show command-line help
                             const options = this.resolve("options");
                             options.help = true;
                         }
@@ -228,10 +306,10 @@ class Yok {
                 },
             };
         };
-        exports.injector.registerCommand(name, factory);
+        this.registerCommand(name, factory);
     }
     getHierarchicalCommandName(parentCommandName, subCommandName) {
-        return [parentCommandName, subCommandName].join("|" /* CommandsDelimiters.HierarchicalCommand */);
+        return [parentCommandName, subCommandName].join(constants_2.CommandsDelimiters.HierarchicalCommand);
     }
     async isValidHierarchicalCommand(commandName, commandArguments) {
         if (_.includes(Object.keys(this.hierarchicalCommands), commandName)) {
@@ -239,9 +317,7 @@ class Yok {
             if (subCommands) {
                 const fullCommandName = this.buildHierarchicalCommand(commandName, commandArguments);
                 if (!fullCommandName) {
-                    // In case buildHierarchicalCommand doesn't find a valid command
-                    // there isn't a valid command or default with those arguments
-                    const errors = exports.injector.resolve("errors");
+                    const errors = this.resolve("errors");
                     errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, commandName);
                 }
                 return true;
@@ -250,32 +326,38 @@ class Yok {
         return false;
     }
     isDefaultCommand(commandName) {
-        return (commandName.indexOf("*" /* CommandsDelimiters.DefaultCommandSymbol */) > 0 &&
-            commandName.indexOf("|" /* CommandsDelimiters.HierarchicalCommand */) > 0);
+        return (commandName.indexOf(constants_2.CommandsDelimiters.DefaultCommandSymbol) > 0 &&
+            commandName.indexOf(constants_2.CommandsDelimiters.HierarchicalCommand) > 0);
     }
-    register(name, resolver, shared) {
+    register(nameOrProviders, resolver, shared) {
+        if (typeof nameOrProviders !== "string") {
+            super.register(nameOrProviders);
+            return;
+        }
         shared = shared === undefined ? true : shared;
-        trace("registered '%s'", name);
-        const dependency = this.modules[name] || {};
-        dependency.shared = shared;
         if (_.isFunction(resolver)) {
-            dependency.resolver = resolver;
+            if (resolver.length === 0 && !resolver.prototype) {
+                super.register({
+                    provide: nameOrProviders,
+                    useFactory: resolver,
+                    shared,
+                });
+                return;
+            }
+            super.register({
+                provide: nameOrProviders,
+                useLegacyClass: resolver,
+                shared,
+            });
         }
         else {
-            dependency.instances = dependency.instances || [];
-            if (shared) {
-                dependency.instances[0] = resolver;
-            }
-            else {
-                dependency.instances.push(resolver);
-            }
+            super.register({ provide: nameOrProviders, useValue: resolver, shared });
         }
-        this.modules[name] = dependency;
     }
     resolveCommand(name) {
         let command;
         const commandModuleName = this.createCommandName(name);
-        if (!this.modules[commandModuleName]) {
+        if (!this.has(commandModuleName)) {
             return null;
         }
         command = this.resolve(commandModuleName);
@@ -284,7 +366,7 @@ class Yok {
     resolveKeyCommand(name) {
         let command;
         const commandModuleName = this.createKeyCommandName(name);
-        if (!this.modules[commandModuleName]) {
+        if (!this.has(commandModuleName)) {
             return null;
         }
         command = this.resolve(commandModuleName);
@@ -292,22 +374,15 @@ class Yok {
     }
     resolve(param, ctorArguments) {
         if (_.isFunction(param)) {
-            return this.resolveConstructor(param, ctorArguments);
-        }
-        else {
-            return this.resolveByName(param, ctorArguments);
+            return this.createInstance(param, [], ctorArguments);
         }
+        return this.getWithLegacyArguments(param, ctorArguments);
     }
-    /* Regex to match dynamic calls in the following format:
-        #{moduleName.functionName} or
-        #{moduleName.functionName(param1)} or
-        #{moduleName.functionName(param1, param2)} - multiple parameters separated with comma are supported
-        Check dynamicCall method for sample usage of this regular expression and see how to determine the passed parameters
-    */
     get dynamicCallRegex() {
         return /#{([^.]+)\.([^}]+?)(\((.+)\))*}/;
     }
     getDynamicCallData(call, args) {
+        (0, deprecation_1.reportDeprecation)({ api: "injector.dynamicCall", detail: call });
         const parsed = call.match(this.dynamicCallRegex);
         const module = this.resolve(parsed[1]);
         if (!args && parsed[3]) {
@@ -322,84 +397,17 @@ class Yok {
         }
         return data;
     }
-    resolveConstructor(ctor, ctorArguments) {
-        (0, helpers_1.annotate)(ctor);
-        const resolvedArgs = ctor.$inject.args.map((paramName) => {
-            if (ctorArguments && ctorArguments.hasOwnProperty(paramName)) {
-                return ctorArguments[paramName];
-            }
-            else {
-                return this.resolve(paramName);
-            }
-        });
-        const name = ctor.$inject.name;
-        if (name && name[0] === name[0].toUpperCase()) {
-            return new ctor(...resolvedArgs);
-        }
-        else {
-            return ctor.apply(null, resolvedArgs);
-        }
-    }
-    resolveByName(name, ctorArguments) {
-        if (name[0] === "$") {
-            name = name.substr(1);
-        }
-        if (this.resolutionProgress[name]) {
-            throw new Error(`Cyclic dependency detected on dependency '${name}'`);
-        }
-        this.resolutionProgress[name] = true;
-        trace("resolving '%s'", name);
-        pushIndent();
-        let dependency;
-        let instance;
-        try {
-            dependency = this.resolveDependency(name);
-            if (!dependency) {
-                throw new Error("unable to resolve " + name);
-            }
-            if (!dependency.instances ||
-                !dependency.instances.length ||
-                !dependency.shared) {
-                if (!dependency.resolver) {
-                    throw new Error("no resolver registered for " + name);
-                }
-                dependency.instances = dependency.instances || [];
-                instance = this.resolveConstructor(dependency.resolver, ctorArguments);
-                dependency.instances.push(instance);
-            }
-            else {
-                instance = _.first(dependency.instances);
-            }
-        }
-        finally {
-            popIndent();
-            delete this.resolutionProgress[name];
-        }
-        return instance;
-    }
-    resolveDependency(name) {
-        const module = this.modules[name];
-        if (!module) {
-            throw new Error("unable to resolve " + name);
-        }
-        if (module.require) {
-            require(module.require);
-        }
-        return module;
-    }
     getRegisteredCommandsNames(includeDev) {
-        const modulesNames = _.keys(this.modules);
-        const commandsNames = _.filter(modulesNames, (moduleName) => _.startsWith(moduleName, `${this.COMMANDS_NAMESPACE}.`));
-        let commands = _.map(commandsNames, (commandName) => commandName.substr(this.COMMANDS_NAMESPACE.length + 1));
+        const commandsNames = this.getRegisteredNames(`${this.COMMANDS_NAMESPACE}.`);
+        let commands = _.map(commandsNames, (commandName) => commandName.slice(this.COMMANDS_NAMESPACE.length + 1));
         if (!includeDev) {
             commands = _.reject(commands, (command) => _.startsWith(command, "dev-"));
         }
         return commands;
     }
     getRegisteredKeyCommandsNames() {
-        const modulesNames = _.keys(this.modules);
-        const commandsNames = _.filter(modulesNames, (moduleName) => _.startsWith(moduleName, `${this.KEY_COMMANDS_NAMESPACE}.`));
-        let commands = _.map(commandsNames, (commandName) => commandName.substr(this.KEY_COMMANDS_NAMESPACE.length + 1));
+        const commandsNames = this.getRegisteredNames(`${this.KEY_COMMANDS_NAMESPACE}.`);
+        const commands = _.map(commandsNames, (commandName) => commandName.slice(this.KEY_COMMANDS_NAMESPACE.length + 1));
         return commands;
     }
     getChildrenCommandsNames(commandName) {
@@ -411,24 +419,24 @@ class Yok {
     createKeyCommandName(name) {
         return `${this.KEY_COMMANDS_NAMESPACE}.${name}`;
     }
-    dispose() {
-        Object.keys(this.modules).forEach((moduleName) => {
-            const instances = this.modules[moduleName].instances;
-            _.forEach(instances, (instance) => {
-                if (instance && instance.dispose && instance !== this) {
-                    instance.dispose();
-                }
-            });
-        });
+    dispose(exclude = []) {
+        super.dispose([this, ...exclude]);
     }
 }
 exports.Yok = Yok;
-if (!global.$injector) {
-    global.$injector = new Yok();
-    exports.injector = global.$injector;
+exports.injector = global.$injector || new Yok();
+Object.defineProperty(global, "$injector", {
+    get: () => exports.injector,
+    set: (value) => {
+        exports.injector = value;
+    },
+    configurable: true,
+});
+function getInjector() {
+    return exports.injector;
 }
 function setGlobalInjector(inj) {
-    global.$injector = exports.injector = inj;
+    exports.injector = inj;
+    global.$injector = inj;
     return inj;
 }
-//# sourceMappingURL=yok.js.map

package/lib/config.d.ts

@@ -0,0 +1,45 @@
+import { IConfiguration, IStaticConfig } from "./declarations";
+import { IFileSystem } from "./common/declarations";
+import { IInjector } from "./common/definitions/yok";
+export declare class Configuration implements IConfiguration {
+    private $fs;
+    DEBUG: boolean;
+    ANDROID_DEBUG_UI: string;
+    USE_POD_SANDBOX: boolean;
+    GA_MEASUREMENT_ID: string;
+    GA_API_SECRET: string;
+    DISABLE_HOOKS: boolean;
+    constructor($fs: IFileSystem);
+    private loadConfig;
+    private getConfigPath;
+}
+export declare class StaticConfig implements IStaticConfig {
+    private $injector;
+    QR_SIZE: number;
+    PROJECT_FILE_NAME: string;
+    CLIENT_NAME_KEY_IN_PROJECT_FILE: string;
+    CLIENT_NAME: string;
+    CLIENT_NAME_ALIAS: string;
+    TRACK_FEATURE_USAGE_SETTING_NAME: string;
+    ERROR_REPORT_SETTING_NAME: string;
+    ANALYTICS_INSTALLATION_ID_SETTING_NAME: string;
+    get PROFILE_DIR_NAME(): string;
+    RESOURCE_DIR_PATH: string;
+    constructor($injector: IInjector);
+    get disableCommandHooks(): boolean;
+    version: any;
+    cliBinPath: string;
+    get HTML_CLI_HELPERS_DIR(): string;
+    get pathToPackageJson(): string;
+    get PATH_TO_BOOTSTRAP(): string;
+    private _adbFilePath;
+    getAdbFilePath(): Promise<string>;
+    private _userAgent;
+    get USER_AGENT_NAME(): string;
+    set USER_AGENT_NAME(userAgentName: string);
+    get MAN_PAGES_DIR(): string;
+    get HTML_PAGES_DIR(): string;
+    get HTML_COMMON_HELPERS_DIR(): string;
+    private getAdbFilePathCore;
+    private spawnPrivateAdb;
+}

package/lib/config.js

@@ -7,14 +7,13 @@ const os = require("os");
 const _ = require("lodash");
 const yok_1 = require("./common/yok");
 class Configuration {
-    /*don't require logger and everything that has logger as dependency in config.js due to cyclic dependency*/
     constructor($fs) {
         this.$fs = $fs;
-        // User specific config
         this.DEBUG = false;
         this.ANDROID_DEBUG_UI = null;
         this.USE_POD_SANDBOX = false;
-        this.GA_TRACKING_ID = null;
+        this.GA_MEASUREMENT_ID = null;
+        this.GA_API_SECRET = null;
         this.DISABLE_HOOKS = false;
         _.extend(this, this.loadConfig("config"));
     }
@@ -49,7 +48,6 @@ class StaticConfig {
         this._userAgent = null;
     }
     get disableCommandHooks() {
-        // Never set this to false because it will duplicate execution of hooks realized through method decoration
         return true;
     }
     get HTML_CLI_HELPERS_DIR() {
@@ -91,7 +89,6 @@ class StaticConfig {
     async getAdbFilePathCore() {
         const $childProcess = this.$injector.resolve("$childProcess");
         try {
-            // Do NOT use the adb wrapper because it will end blow up with Segmentation fault because the wrapper uses this method!!!
             const proc = await $childProcess.spawnFromEvent("adb", ["version"], "exit", undefined, { throwError: false });
             if (proc.stderr) {
                 return await this.spawnPrivateAdb();
@@ -104,40 +101,23 @@ class StaticConfig {
         }
         return "adb";
     }
-    /*
-        Problem:
-        1. Adb forks itself as a server which keeps running until adb kill-server is invoked or crashes
-        2. On Windows running processes lock their image files due to memory mapping. Locked files prevent their parent directories from deletion and cannot be overwritten.
-        3. Update and uninstall scenarios are broken
-        Solution:
-        - Copy adb and associated files into a temporary directory. Let this copy of adb run persistently
-        - On Posix OSes, immediately delete the file to not take file space
-        - Tie common lib version to updates of adb, so that when we integrate a newer adb we can use it
-        - Adb is named differently on OSes and may have additional files. The code is hairy to accommodate these differences
-     */
     async spawnPrivateAdb() {
         const $fs = this.$injector.resolve("$fs"), $childProcess = this.$injector.resolve("$childProcess"), $hostInfo = this.$injector.resolve("$hostInfo");
-        // prepare the directory to host our copy of adb
         const defaultAdbDirPath = path.join(__dirname, "common", "resources", "platform-tools", "android", process.platform);
         const pathToPackageJson = path.join(__dirname, "..", "package.json");
         const nsCliVersion = require(pathToPackageJson).version;
         const tmpDir = path.join(os.tmpdir(), `nativescript-cli-${nsCliVersion}`);
         $fs.createDirectory(tmpDir);
-        // copy the adb and associated files
         const targetAdb = path.join(tmpDir, "adb");
-        // In case directory is missing or it's empty, copy the new adb
         if (!$fs.exists(tmpDir) || !$fs.readDirectory(tmpDir).length) {
-            shelljs.cp(path.join(defaultAdbDirPath, "*"), tmpDir); // deliberately ignore copy errors
-            // adb loses its executable bit when packed inside electron asar file. Manually fix the issue
+            shelljs.cp(path.join(defaultAdbDirPath, "*"), tmpDir);
             if (!$hostInfo.isWindows) {
                 shelljs.chmod("+x", targetAdb);
             }
         }
-        // let adb start its global server
         await $childProcess.spawnFromEvent(targetAdb, ["start-server"], "exit");
         return targetAdb;
     }
 }
 exports.StaticConfig = StaticConfig;
 yok_1.injector.register("staticConfig", StaticConfig);
-//# sourceMappingURL=config.js.map

package/lib/constants-provider.d.ts

@@ -0,0 +1,4 @@
+import { IDictionary } from "./common/declarations";
+export declare class Constants implements IDictionary<any> {
+    constructor();
+}

package/lib/constants-provider.js

@@ -10,4 +10,3 @@ class Constants {
 }
 exports.Constants = Constants;
 yok_1.injector.register("constants", Constants);
-//# sourceMappingURL=constants-provider.js.map