nativescript 8.9.0-dev.0 → 8.9.0-dev.2

package/lib/common/host-info.js

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HostInfo = void 0;
 const decorators_1 = require("./decorators");
@@ -44,32 +53,37 @@ class HostInfo {
     get isLinux64() {
         return this.isLinux && process.config.variables.host_arch === "x64";
     }
-    async getMacOSVersion() {
-        if (!this.isDarwin) {
-            return null;
-        }
-        const systemProfileCommand = "system_profiler SPSoftwareDataType -detailLevel mini";
-        this.$logger.trace("Trying to get macOS version.");
-        let macOSVersion;
-        try {
-            const systemProfileOutput = await this.$childProcess.exec(systemProfileCommand);
-            const versionRegExp = /System Version:\s+?macOS\s+?(\d+\.\d+)(\.\d+)?\s+/g;
-            const regExpMatchers = versionRegExp.exec(systemProfileOutput);
-            macOSVersion = regExpMatchers && regExpMatchers[1];
-            if (macOSVersion) {
-                this.$logger.trace(`macOS version based on system_profiler is ${macOSVersion}.`);
-                return macOSVersion;
+    getMacOSVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isDarwin) {
+                return null;
             }
-            this.$logger.trace(`Unable to get macOS version from ${systemProfileCommand} output.`);
-        }
-        catch (err) {
-            this.$logger.trace(`Unable to get macOS version from ${systemProfileCommand}. Error is: ${err}`);
-        }
-        const osRelease = this.$osInfo.release();
-        const majorVersion = osRelease && _.first(osRelease.split("."));
-        macOSVersion = majorVersion && `10.${+majorVersion - 4}`;
-        this.$logger.trace(`macOS version based on os.release() (${osRelease}) is ${macOSVersion}.`);
-        return macOSVersion;
+            const systemProfileCommand = "system_profiler SPSoftwareDataType -detailLevel mini";
+            this.$logger.trace("Trying to get macOS version.");
+            let macOSVersion;
+            try {
+                const systemProfileOutput = yield this.$childProcess.exec(systemProfileCommand);
+                const versionRegExp = /System Version:\s+?macOS\s+?(\d+\.\d+)(\.\d+)?\s+/g;
+                const regExpMatchers = versionRegExp.exec(systemProfileOutput);
+                macOSVersion = regExpMatchers && regExpMatchers[1];
+                if (macOSVersion) {
+                    this.$logger.trace(`macOS version based on system_profiler is ${macOSVersion}.`);
+                    return macOSVersion;
+                }
+                this.$logger.trace(`Unable to get macOS version from ${systemProfileCommand} output.`);
+            }
+            catch (err) {
+                this.$logger.trace(`Unable to get macOS version from ${systemProfileCommand}. Error is: ${err}`);
+            }
+            // https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
+            // Each macOS version is labeled 10.<version>, where it looks like <versions> is taken from the major version returned by os.release() (16.x.x for example) and subtracting 4 from it.
+            // So the version becomes "10.12" in this case.
+            const osRelease = this.$osInfo.release();
+            const majorVersion = osRelease && _.first(osRelease.split("."));
+            macOSVersion = majorVersion && `10.${+majorVersion - 4}`;
+            this.$logger.trace(`macOS version based on os.release() (${osRelease}) is ${macOSVersion}.`);
+            return macOSVersion;
+        });
     }
     dotNetVersion() {
         if (this.isWindows) {
@@ -93,22 +107,23 @@ class HostInfo {
             return Promise.resolve(null);
         }
     }
-    async isDotNet40Installed(message) {
-        if (this.isWindows) {
-            try {
-                await this.dotNetVersion();
-                return true;
+    isDotNet40Installed(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isWindows) {
+                try {
+                    yield this.dotNetVersion();
+                    return true;
+                }
+                catch (e) {
+                    this.$errors.fail(message || "An error occurred while reading the registry.");
+                }
             }
-            catch (e) {
-                this.$errors.fail(message || "An error occurred while reading the registry.");
+            else {
+                return false;
             }
-        }
-        else {
-            return false;
-        }
+        });
     }
 }
-exports.HostInfo = HostInfo;
 HostInfo.WIN32_NAME = "win32";
 HostInfo.PROCESSOR_ARCHITEW6432 = "PROCESSOR_ARCHITEW6432";
 HostInfo.DARWIN_OS_NAME = "darwin";
@@ -117,4 +132,6 @@ HostInfo.DOT_NET_REGISTRY_PATH = "\\Software\\Microsoft\\NET Framework Setup\\ND
 __decorate([
     (0, decorators_1.cache)()
 ], HostInfo.prototype, "getMacOSVersion", null);
+exports.HostInfo = HostInfo;
 yok_1.injector.register("hostInfo", HostInfo);
+//# sourceMappingURL=host-info.js.map

package/lib/common/http-client.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.HttpClient = void 0;
 const _ = require("lodash");
@@ -14,90 +23,103 @@ class HttpClient {
         this.$proxyService = $proxyService;
         this.$staticConfig = $staticConfig;
     }
-    async httpRequest(options, proxySettings) {
-        try {
-            const result = await this.httpRequestCore(options, proxySettings);
-            return {
-                response: result,
-                body: result.body,
-                headers: result.headers,
-            };
-        }
-        catch (err) {
-            if (err.message === HttpClient.STUCK_REQUEST_ERROR_MESSAGE ||
-                err.message === HttpClient.STUCK_RESPONSE_ERROR_MESSAGE) {
-                this.$logger.warn("%s Retrying request to %s...", err.message, options.url || options);
-                const retryResult = await this.httpRequestCore(options, proxySettings);
+    httpRequest(options, proxySettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.httpRequestCore(options, proxySettings);
                 return {
-                    response: retryResult,
-                    body: retryResult.body,
-                    headers: retryResult.headers,
+                    response: result,
+                    body: result.body,
+                    headers: result.headers,
                 };
             }
-            throw err;
-        }
+            catch (err) {
+                if (err.message === HttpClient.STUCK_REQUEST_ERROR_MESSAGE ||
+                    err.message === HttpClient.STUCK_RESPONSE_ERROR_MESSAGE) {
+                    // Retry the request immediately because there are at least 10 seconds between the two requests.
+                    // We have to retry only once the sporadically stuck requests/responses.
+                    // We can add exponential backoff retry here if we decide that we need to workaround bigger network issues on the client side.
+                    this.$logger.warn("%s Retrying request to %s...", err.message, options.url || options);
+                    const retryResult = yield this.httpRequestCore(options, proxySettings);
+                    return {
+                        response: retryResult,
+                        body: retryResult.body,
+                        headers: retryResult.headers,
+                    };
+                }
+                throw err;
+            }
+        });
     }
-    async httpRequestCore(options, proxySettings) {
-        if (_.isString(options)) {
-            options = {
-                url: options,
-                method: "GET",
-            };
-        }
-        const cliProxySettings = await this.$proxyService.getCache();
-        const requestProto = options.proto || "http";
-        options.headers = options.headers || {};
-        const headers = options.headers;
-        await this.useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto);
-        if (!headers["User-Agent"]) {
-            if (!this.defaultUserAgent) {
-                this.defaultUserAgent = `${this.$staticConfig.USER_AGENT_NAME}/${this.$staticConfig.version} (Node.js ${process.versions.node}; ${process.platform}; ${process.arch})`;
-                this.$logger.trace("User-Agent: %s", this.defaultUserAgent);
+    httpRequestCore(options, proxySettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_.isString(options)) {
+                options = {
+                    url: options,
+                    method: "GET",
+                };
             }
-            headers["User-Agent"] = this.defaultUserAgent;
-        }
-        if (!headers["Accept-Encoding"]) {
-            headers["Accept-Encoding"] = "gzip,deflate";
-        }
-        this.$logger.trace("httpRequest: %s", util.inspect(options));
-        let agent;
-        if (cliProxySettings) {
-            agent = tunnel.httpsOverHttp({
-                proxy: {
-                    host: cliProxySettings.hostname,
-                    port: parseInt(cliProxySettings.port),
-                },
-            });
-        }
-        const result = await (0, axios_1.default)({
-            url: options.url,
-            headers: options.headers,
-            method: options.method,
-            proxy: false,
-            httpAgent: agent,
-            data: options.body,
-        }).catch((err) => {
-            this.$logger.trace("An error occurred while sending the request:", err);
-            if (err.response) {
-                const errorMessage = this.getErrorMessage(err.response.status, null);
-                err.proxyAuthenticationRequired =
-                    err.response.status === constants_1.HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED;
-                err.message = errorMessage || err.message;
+            const cliProxySettings = yield this.$proxyService.getCache();
+            const requestProto = options.proto || "http";
+            options.headers = options.headers || {};
+            const headers = options.headers;
+            yield this.useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto);
+            if (!headers["User-Agent"]) {
+                if (!this.defaultUserAgent) {
+                    //TODO: the user agent client name is also passed explicitly during login and should be kept in sync
+                    this.defaultUserAgent = `${this.$staticConfig.USER_AGENT_NAME}/${this.$staticConfig.version} (Node.js ${process.versions.node}; ${process.platform}; ${process.arch})`;
+                    this.$logger.trace("User-Agent: %s", this.defaultUserAgent);
+                }
+                headers["User-Agent"] = this.defaultUserAgent;
             }
-            else if (err.request) {
+            if (!headers["Accept-Encoding"]) {
+                headers["Accept-Encoding"] = "gzip,deflate";
             }
-            else {
+            this.$logger.trace("httpRequest: %s", util.inspect(options));
+            let agent;
+            if (cliProxySettings) {
+                agent = tunnel.httpsOverHttp({
+                    proxy: {
+                        host: cliProxySettings.hostname,
+                        port: parseInt(cliProxySettings.port),
+                    },
+                });
+            }
+            const result = yield (0, axios_1.default)({
+                url: options.url,
+                headers: options.headers,
+                method: options.method,
+                proxy: false,
+                httpAgent: agent,
+                data: options.body,
+            }).catch((err) => {
+                this.$logger.trace("An error occurred while sending the request:", err);
+                if (err.response) {
+                    // The request was made and the server responded with a status code
+                    // that falls out of the range of 2xx
+                    const errorMessage = this.getErrorMessage(err.response.status, null);
+                    err.proxyAuthenticationRequired =
+                        err.response.status === constants_1.HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED;
+                    err.message = errorMessage || err.message;
+                }
+                else if (err.request) {
+                    // The request was made but no response was received
+                    // `err.request` is an instance of XMLHttpRequest in the browser and an instance of
+                }
+                else {
+                    // Something happened in setting up the request that triggered an Error
+                }
+                throw err;
+            });
+            if (result) {
+                this.$logger.trace("httpRequest: Done. code = %d", result.status.toString());
+                return {
+                    response: result,
+                    body: JSON.stringify(result.data),
+                    headers: result.headers,
+                };
             }
-            throw err;
         });
-        if (result) {
-            this.$logger.trace("httpRequest: Done. code = %d", result.status.toString());
-            return {
-                response: result,
-                body: JSON.stringify(result.data),
-                headers: result.headers,
-            };
-        }
     }
     getErrorMessage(statusCode, body) {
         if (statusCode === constants_1.HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED) {
@@ -132,27 +154,40 @@ class HttpClient {
             return body;
         }
     }
-    async useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto) {
-        const isLocalRequest = options.host === "localhost" || options.host === "127.0.0.1";
-        if (!isLocalRequest && (proxySettings || cliProxySettings)) {
-            const proto = (proxySettings && proxySettings.protocol) ||
-                cliProxySettings.protocol ||
-                "http:";
-            const host = (proxySettings && proxySettings.hostname) || cliProxySettings.hostname;
-            const port = (proxySettings && proxySettings.port) || cliProxySettings.port;
-            let credentialsPart = "";
-            if (cliProxySettings.username && cliProxySettings.password) {
-                credentialsPart = `${cliProxySettings.username}:${cliProxySettings.password}@`;
+    /**
+     * This method respects the proxySettings (or proxyCache) by modifying headers and options passed to http(s) module.
+     * @param {IProxySettings} proxySettings The settings passed for this specific call.
+     * @param {IProxySettings} cliProxySettings The globally set proxy for this CLI.
+     * @param {any}options The object that will be passed to http(s) module.
+     * @param {any} headers Headers of the current request.
+     * @param {string} requestProto The protocol used for the current request - http or https.
+     */
+    useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isLocalRequest = options.host === "localhost" || options.host === "127.0.0.1";
+            // don't use the proxy for requests to localhost
+            if (!isLocalRequest && (proxySettings || cliProxySettings)) {
+                const proto = (proxySettings && proxySettings.protocol) ||
+                    cliProxySettings.protocol ||
+                    "http:";
+                const host = (proxySettings && proxySettings.hostname) || cliProxySettings.hostname;
+                const port = (proxySettings && proxySettings.port) || cliProxySettings.port;
+                let credentialsPart = "";
+                if (cliProxySettings.username && cliProxySettings.password) {
+                    credentialsPart = `${cliProxySettings.username}:${cliProxySettings.password}@`;
+                }
+                // Note that proto ends with :
+                options.proxy = `${proto}//${credentialsPart}${host}:${port}`;
+                options.rejectUnauthorized = proxySettings
+                    ? proxySettings.rejectUnauthorized
+                    : cliProxySettings.rejectUnauthorized;
+                this.$logger.trace("Using proxy: %s", options.proxy);
             }
-            options.proxy = `${proto}//${credentialsPart}${host}:${port}`;
-            options.rejectUnauthorized = proxySettings
-                ? proxySettings.rejectUnauthorized
-                : cliProxySettings.rejectUnauthorized;
-            this.$logger.trace("Using proxy: %s", options.proxy);
-        }
+        });
     }
 }
-exports.HttpClient = HttpClient;
 HttpClient.STUCK_REQUEST_ERROR_MESSAGE = "The request can't receive any response.";
 HttpClient.STUCK_RESPONSE_ERROR_MESSAGE = "Can't receive all parts of the response.";
+exports.HttpClient = HttpClient;
 yok_1.injector.register("httpClient", HttpClient);
+//# sourceMappingURL=http-client.js.map

package/lib/common/logger/appenders/cli-appender.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configure = configure;
+exports.configure = void 0;
 const constants_1 = require("../../../constants");
 function cliAppender(layout) {
     const appender = (loggingEvent) => {
@@ -15,9 +15,14 @@ function cliAppender(layout) {
     return appender;
 }
 function configure(config, layouts) {
+    // the default layout for the appender
     let layout = layouts.messagePassThroughLayout;
+    // check if there is another layout specified
     if (config.layout) {
         layout = layouts.layout(config.layout.type, config.layout);
     }
+    // create a new appender instance
     return cliAppender(layout);
 }
+exports.configure = configure;
+//# sourceMappingURL=cli-appender.js.map

package/lib/common/logger/appenders/emit-appender.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configure = configure;
+exports.configure = void 0;
 const constants_1 = require("../../../constants");
 function emitAppender(layout, emitter) {
     const appender = (loggingEvent) => {
@@ -21,9 +21,14 @@ function configure(config, layouts) {
     if (!config.emitter.emit || typeof config.emitter.emit !== "function") {
         throw new Error("The passed emitter must be instance of EventEmitter");
     }
+    // the default layout for the appender
     let layout = layouts.messagePassThroughLayout;
+    // check if there is another layout specified
     if (config.layout) {
         layout = layouts.layout(config.layout.type, config.layout);
     }
+    // create a new appender instance
     return emitAppender(layout, config.emitter);
 }
+exports.configure = configure;
+//# sourceMappingURL=emit-appender.js.map

package/lib/common/logger/layouts/cli-layout.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.layout = layout;
+exports.layout = void 0;
 const util_1 = require("util");
 const helpers_1 = require("../../helpers");
 const constants_1 = require("../../../constants");
@@ -30,3 +30,5 @@ function layout(config) {
         return msg;
     };
 }
+exports.layout = layout;
+//# sourceMappingURL=cli-layout.js.map

package/lib/common/logger/logger.js

@@ -18,7 +18,7 @@ const cli_layout_1 = require("./layouts/cli-layout");
 const constants_1 = require("../../constants");
 const yok_1 = require("../yok");
 const color_1 = require("../../color");
-const marked_terminal_1 = require("marked-terminal");
+const TerminalRenderer = require("marked-terminal");
 class Logger {
     constructor($config) {
         this.$config = $config;
@@ -98,9 +98,11 @@ class Logger {
         if (typeof item === "string") {
             return item;
         }
+        // do not try to read streams, because they may not be rewindable
         if (item instanceof stream.Readable) {
             return "[ReadableStream]";
         }
+        // There's no point in printing buffers
         if (item instanceof Buffer) {
             return "[Buffer]";
         }
@@ -123,8 +125,8 @@ class Logger {
                 },
             },
         };
-        marked_1.marked.use((0, marked_terminal_1.markedTerminal)(opts));
-        const formattedMessage = marked_1.marked.parse(util.format.apply(null, args));
+        marked_1.marked.setOptions({ renderer: new TerminalRenderer(opts) });
+        const formattedMessage = (0, marked_1.marked)(util.format.apply(null, args));
         this.info(formattedMessage, { [constants_1.LoggerConfigData.skipNewLine]: true });
     }
     isVerbose() {
@@ -153,12 +155,14 @@ class Logger {
     getLogOptionsForMessage(data) {
         const loggerOptionKeys = _.keys(constants_1.LoggerConfigData);
         const dataToCheck = data.filter((el) => {
+            // objects created with Object.create(null) do not have `hasOwnProperty` function
             if (!!el &&
                 typeof el === "object" &&
                 el.hasOwnProperty &&
                 typeof el.hasOwnProperty === "function") {
                 for (const key of loggerOptionKeys) {
                     if (el.hasOwnProperty(key)) {
+                        // include only the elements which have one of the keys we've specified as logger options
                         return true;
                     }
                 }
@@ -192,8 +196,9 @@ class Logger {
         });
     }
 }
-exports.Logger = Logger;
 __decorate([
     (0, decorators_1.cache)()
 ], Logger.prototype, "initialize", null);
+exports.Logger = Logger;
 yok_1.injector.register("logger", Logger);
+//# sourceMappingURL=logger.js.map

package/lib/common/messages/messages.js

@@ -1,7 +1,11 @@
 "use strict";
+//
+// automatically generated code; do not edit manually!
+//
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Messages = void 0;
 const yok_1 = require("../yok");
+/* tslint:disable:all */
 class Messages {
     constructor() {
         this.Devices = {
@@ -13,3 +17,5 @@ class Messages {
 }
 exports.Messages = Messages;
 yok_1.injector.register("messages", Messages);
+/* tslint:enable */
+//# sourceMappingURL=messages.js.map