@akylas/nativescript-cli 8.8.2 → 8.8.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,34 +44,32 @@ 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;
             }
-            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}`);
+        }
+        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) {
@@ -104,23 +93,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";
@@ -129,5 +117,4 @@ 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);

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,94 +14,90 @@ 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) {
+                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) {
-                    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) {
-                    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) {
+                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) {
+                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) {
             }
-            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) {
-                    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) {
-                }
-                else {
-                }
-                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 {
             }
+            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) {
@@ -145,29 +132,27 @@ class HttpClient {
             return body;
         }
     }
-    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";
-            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}@`;
-                }
-                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";
+        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}@`;
             }
-        });
+            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);

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) => {
@@ -21,4 +21,3 @@ function configure(config, layouts) {
     }
     return cliAppender(layout);
 }
-exports.configure = configure;

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) => {
@@ -27,4 +27,3 @@ function configure(config, layouts) {
     }
     return emitAppender(layout, config.emitter);
 }
-exports.configure = configure;

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,4 +30,3 @@ function layout(config) {
         return msg;
     };
 }
-exports.layout = layout;

package/lib/common/logger/logger.js

@@ -192,8 +192,8 @@ class Logger {
         });
     }
 }
+exports.Logger = Logger;
 __decorate([
     (0, decorators_1.cache)()
 ], Logger.prototype, "initialize", null);
-exports.Logger = Logger;
 yok_1.injector.register("logger", Logger);