nativescript 8.9.0-dev.2 → 8.9.0-dev.4

package/lib/common/host-info.js

@@ -5,15 +5,6 @@ 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");
@@ -53,37 +44,35 @@ class HostInfo {
     get isLinux64() {
         return this.isLinux && process.config.variables.host_arch === "x64";
     }
-    getMacOSVersion() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = 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}`);
+    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;
             }
-            // 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;
-        });
+            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) {
@@ -107,23 +96,22 @@ class HostInfo {
             return Promise.resolve(null);
         }
     }
-    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.");
-                }
+    async isDotNet40Installed(message) {
+        if (this.isWindows) {
+            try {
+                await this.dotNetVersion();
+                return true;
             }
-            else {
-                return false;
+            catch (e) {
+                this.$errors.fail(message || "An error occurred while reading the registry.");
             }
-        });
+        }
+        else {
+            return false;
+        }
     }
 }
+exports.HostInfo = HostInfo;
 HostInfo.WIN32_NAME = "win32";
 HostInfo.PROCESSOR_ARCHITEW6432 = "PROCESSOR_ARCHITEW6432";
 HostInfo.DARWIN_OS_NAME = "darwin";
@@ -132,6 +120,5 @@ 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,13 +1,4 @@
 "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");
@@ -23,103 +14,99 @@ class HttpClient {
         this.$proxyService = $proxyService;
         this.$staticConfig = $staticConfig;
     }
-    httpRequest(options, proxySettings) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const result = yield this.httpRequestCore(options, proxySettings);
+    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) {
+                // 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 = await this.httpRequestCore(options, proxySettings);
                 return {
-                    response: result,
-                    body: result.body,
-                    headers: result.headers,
+                    response: retryResult,
+                    body: retryResult.body,
+                    headers: retryResult.headers,
                 };
             }
-            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;
-            }
-        });
+            throw err;
+        }
     }
-    httpRequestCore(options, proxySettings) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isString(options)) {
-                options = {
-                    url: options,
-                    method: "GET",
-                };
-            }
-            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;
+    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) {
+                //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);
             }
-            if (!headers["Accept-Encoding"]) {
-                headers["Accept-Encoding"] = "gzip,deflate";
+            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) {
+                // 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;
             }
-            this.$logger.trace("httpRequest: %s", util.inspect(options));
-            let agent;
-            if (cliProxySettings) {
-                agent = tunnel.httpsOverHttp({
-                    proxy: {
-                        host: cliProxySettings.hostname,
-                        port: parseInt(cliProxySettings.port),
-                    },
-                });
+            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
             }
-            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,
-                };
+            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,
+            };
+        }
     }
     getErrorMessage(statusCode, body) {
         if (statusCode === constants_1.HttpStatusCodes.PROXY_AUTHENTICATION_REQUIRED) {
@@ -162,32 +149,30 @@ class HttpClient {
      * @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);
+    async useProxySettings(proxySettings, cliProxySettings, options, headers, requestProto) {
+        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);
+        }
     }
 }
+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 = void 0;
+exports.configure = configure;
 const constants_1 = require("../../../constants");
 function cliAppender(layout) {
     const appender = (loggingEvent) => {
@@ -24,5 +24,4 @@ function configure(config, layouts) {
     // 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 = void 0;
+exports.configure = configure;
 const constants_1 = require("../../../constants");
 function emitAppender(layout, emitter) {
     const appender = (loggingEvent) => {
@@ -30,5 +30,4 @@ function configure(config, layouts) {
     // 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 = void 0;
+exports.layout = layout;
 const util_1 = require("util");
 const helpers_1 = require("../../helpers");
 const constants_1 = require("../../../constants");
@@ -30,5 +30,4 @@ 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 TerminalRenderer = require("marked-terminal");
+const marked_terminal_1 = require("marked-terminal");
 class Logger {
     constructor($config) {
         this.$config = $config;
@@ -125,8 +125,8 @@ class Logger {
                 },
             },
         };
-        marked_1.marked.setOptions({ renderer: new TerminalRenderer(opts) });
-        const formattedMessage = (0, marked_1.marked)(util.format.apply(null, args));
+        marked_1.marked.use((0, marked_terminal_1.markedTerminal)(opts));
+        const formattedMessage = marked_1.marked.parse(util.format.apply(null, args));
         this.info(formattedMessage, { [constants_1.LoggerConfigData.skipNewLine]: true });
     }
     isVerbose() {
@@ -196,9 +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