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

package/lib/common/yok.js

@@ -1,14 +1,28 @@
 "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.Yok = exports.injector = void 0;
-exports.register = register;
-exports.setGlobalInjector = setGlobalInjector;
+exports.setGlobalInjector = exports.Yok = exports.register = exports.injector = void 0;
 const path = require("path");
 const _ = require("lodash");
 const helpers_1 = require("./helpers");
 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 += "  ";
@@ -26,9 +40,11 @@ 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);
     };
 }
+exports.register = register;
 class Yok {
     constructor() {
         this.overrideAlreadyRequiredModule = false;
@@ -44,7 +60,7 @@ class Yok {
     }
     requireCommand(names, file) {
         forEachName(names, (commandName) => {
-            const commands = commandName.split("|");
+            const commands = commandName.split("|" /* CommandsDelimiters.HierarchicalCommand */);
             if (commands.length > 1) {
                 if (_.startsWith(commands[1], "*") &&
                     this.modules[this.createCommandName(commands[0])]) {
@@ -54,7 +70,7 @@ class Yok {
                 if (!this.hierarchicalCommands[parentCommandName]) {
                     this.hierarchicalCommands[parentCommandName] = [];
                 }
-                this.hierarchicalCommands[parentCommandName].push(_.tail(commands).join("|"));
+                this.hierarchicalCommands[parentCommandName].push(_.tail(commands).join("|" /* CommandsDelimiters.HierarchicalCommand */));
             }
             if (commands.length > 1 &&
                 !this.modules[this.createCommandName(commands[0])]) {
@@ -125,7 +141,7 @@ class Yok {
     }
     registerCommand(names, resolver) {
         forEachName(names, (name) => {
-            const commands = name.split("|");
+            const commands = name.split("|" /* CommandsDelimiters.HierarchicalCommand */);
             this.register(this.createCommandName(name), resolver);
             if (commands.length > 1) {
                 this.createHierarchicalCommand(commands[0]);
@@ -137,7 +153,7 @@ class Yok {
     }
     getDefaultCommand(name, commandArguments) {
         const subCommands = this.hierarchicalCommands[name];
-        const defaultCommand = _.find(subCommands, (command) => _.some(command.split("|"), (c) => _.startsWith(c, "*")));
+        const defaultCommand = _.find(subCommands, (command) => _.some(command.split("|" /* CommandsDelimiters.HierarchicalCommand */), (c) => _.startsWith(c, "*" /* CommandsDelimiters.DefaultCommandSymbol */)));
         return defaultCommand;
     }
     buildHierarchicalCommand(parentCommandName, commandLineArguments) {
@@ -153,7 +169,7 @@ class Yok {
             remainingArguments = _.tail(remainingArguments);
             if ((matchingSubCommandName = _.find(subCommands, (sc) => sc === currentSubCommandName ||
                 sc ===
-                    `${"*"}${currentSubCommandName}`))) {
+                    `${"*" /* CommandsDelimiters.DefaultCommandSymbol */}${currentSubCommandName}`))) {
                 finalSubCommandName = matchingSubCommandName;
                 finalRemainingArguments = remainingArguments;
             }
@@ -162,8 +178,8 @@ class Yok {
             finalSubCommandName =
                 this.getDefaultCommand(parentCommandName, commandLineArguments) || "";
             finalRemainingArguments = _.difference(commandLineArguments, finalSubCommandName
-                .split("|")
-                .map((command) => _.startsWith(command, "*")
+                .split("|" /* CommandsDelimiters.HierarchicalCommand */)
+                .map((command) => _.startsWith(command, "*" /* CommandsDelimiters.DefaultCommandSymbol */)
                 ? command.substr(1)
                 : command));
         }
@@ -179,7 +195,7 @@ class Yok {
             return {
                 disableAnalytics: true,
                 isHierarchicalCommand: true,
-                execute: async (args) => {
+                execute: (args) => __awaiter(this, void 0, void 0, function* () {
                     const commandsService = exports.injector.resolve("commandsService");
                     let commandName = null;
                     const defaultCommand = this.getDefaultCommand(name, args);
@@ -194,7 +210,9 @@ class Yok {
                             commandName = defaultCommand
                                 ? this.getHierarchicalCommandName(name, defaultCommand)
                                 : "help";
-                            if (_.includes(this.hierarchicalCommands[name], "*" + args[0])) {
+                            // If we'll execute the default command, but it's full name had been written by the user
+                            // for example "tns 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])) {
                                 commandArguments = _.tail(args);
                             }
                             else {
@@ -203,41 +221,47 @@ 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;
                         }
                     }
-                    await commandsService.tryExecuteCommand(commandName, commandName === "help" ? [name] : commandArguments);
-                },
+                    yield commandsService.tryExecuteCommand(commandName, commandName === "help" ? [name] : commandArguments);
+                }),
             };
         };
         exports.injector.registerCommand(name, factory);
     }
     getHierarchicalCommandName(parentCommandName, subCommandName) {
-        return [parentCommandName, subCommandName].join("|");
-    }
-    async isValidHierarchicalCommand(commandName, commandArguments) {
-        if (_.includes(Object.keys(this.hierarchicalCommands), commandName)) {
-            const subCommands = this.hierarchicalCommands[commandName];
-            if (subCommands) {
-                const fullCommandName = this.buildHierarchicalCommand(commandName, commandArguments);
-                if (!fullCommandName) {
-                    const errors = exports.injector.resolve("errors");
-                    errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, commandName);
+        return [parentCommandName, subCommandName].join("|" /* CommandsDelimiters.HierarchicalCommand */);
+    }
+    isValidHierarchicalCommand(commandName, commandArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_.includes(Object.keys(this.hierarchicalCommands), commandName)) {
+                const subCommands = this.hierarchicalCommands[commandName];
+                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");
+                        errors.failWithHelp(constants_1.ERROR_NO_VALID_SUBCOMMAND_FORMAT, commandName);
+                    }
+                    return true;
                 }
-                return true;
             }
-        }
-        return false;
+            return false;
+        });
     }
     isDefaultCommand(commandName) {
-        return (commandName.indexOf("*") > 0 &&
-            commandName.indexOf("|") > 0);
+        return (commandName.indexOf("*" /* CommandsDelimiters.DefaultCommandSymbol */) > 0 &&
+            commandName.indexOf("|" /* CommandsDelimiters.HierarchicalCommand */) > 0);
     }
     register(name, resolver, shared) {
         shared = shared === undefined ? true : shared;
@@ -284,6 +308,12 @@ class Yok {
             return this.resolveByName(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 /#{([^.]+)\.([^}]+?)(\((.+)\))*}/;
     }
@@ -295,12 +325,14 @@ class Yok {
         }
         return module[parsed[2]].apply(module, args);
     }
-    async dynamicCall(call, args) {
-        const data = this.getDynamicCallData(call, args);
-        if ((0, helpers_1.isPromise)(data)) {
-            return await data;
-        }
-        return data;
+    dynamicCall(call, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = this.getDynamicCallData(call, args);
+            if ((0, helpers_1.isPromise)(data)) {
+                return yield data;
+            }
+            return data;
+        });
     }
     resolveConstructor(ctor, ctorArguments) {
         (0, helpers_1.annotate)(ctor);
@@ -411,3 +443,5 @@ function setGlobalInjector(inj) {
     global.$injector = exports.injector = inj;
     return inj;
 }
+exports.setGlobalInjector = setGlobalInjector;
+//# sourceMappingURL=yok.js.map

package/lib/config.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticConfig = exports.Configuration = void 0;
 const path = require("path");
@@ -7,8 +16,10 @@ 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;
@@ -47,6 +58,7 @@ 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() {
@@ -58,14 +70,16 @@ class StaticConfig {
     get PATH_TO_BOOTSTRAP() {
         return path.join(__dirname, "bootstrap.js");
     }
-    async getAdbFilePath() {
-        if (!this._adbFilePath) {
-            const androidToolsInfo = this.$injector.resolve("androidToolsInfo");
-            this._adbFilePath =
-                (await androidToolsInfo.getPathToAdbFromAndroidHome()) ||
-                    (await this.getAdbFilePathCore());
-        }
-        return this._adbFilePath;
+    getAdbFilePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._adbFilePath) {
+                const androidToolsInfo = this.$injector.resolve("androidToolsInfo");
+                this._adbFilePath =
+                    (yield androidToolsInfo.getPathToAdbFromAndroidHome()) ||
+                        (yield this.getAdbFilePathCore());
+            }
+            return this._adbFilePath;
+        });
     }
     get USER_AGENT_NAME() {
         if (!this._userAgent) {
@@ -85,38 +99,60 @@ class StaticConfig {
     get HTML_COMMON_HELPERS_DIR() {
         return path.join(__dirname, "common", "docs", "helpers");
     }
-    async getAdbFilePathCore() {
-        const $childProcess = this.$injector.resolve("$childProcess");
-        try {
-            const proc = await $childProcess.spawnFromEvent("adb", ["version"], "exit", undefined, { throwError: false });
-            if (proc.stderr) {
-                return await this.spawnPrivateAdb();
+    getAdbFilePathCore() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield $childProcess.spawnFromEvent("adb", ["version"], "exit", undefined, { throwError: false });
+                if (proc.stderr) {
+                    return yield this.spawnPrivateAdb();
+                }
             }
-        }
-        catch (e) {
-            if (e.code === "ENOENT") {
-                return await this.spawnPrivateAdb();
+            catch (e) {
+                if (e.code === "ENOENT") {
+                    return yield this.spawnPrivateAdb();
+                }
             }
-        }
-        return "adb";
-    }
-    async spawnPrivateAdb() {
-        const $fs = this.$injector.resolve("$fs"), $childProcess = this.$injector.resolve("$childProcess"), $hostInfo = this.$injector.resolve("$hostInfo");
-        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);
-        const targetAdb = path.join(tmpDir, "adb");
-        if (!$fs.exists(tmpDir) || !$fs.readDirectory(tmpDir).length) {
-            shelljs.cp(path.join(defaultAdbDirPath, "*"), tmpDir);
-            if (!$hostInfo.isWindows) {
-                shelljs.chmod("+x", targetAdb);
+            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
+     */
+    spawnPrivateAdb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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
+                if (!$hostInfo.isWindows) {
+                    shelljs.chmod("+x", targetAdb);
+                }
             }
-        }
-        await $childProcess.spawnFromEvent(targetAdb, ["start-server"], "exit");
-        return targetAdb;
+            // let adb start its global server
+            yield $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.js

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